conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
const nativeExtensions = ['node_sqlite3.node', 'fse.node', 'crfsuite.node', 'fasttext.node', 'node-svm.node']
=======
const nativeExtensions = ['node_sqlite3.node', 'fse.node', 'crfsuite.node', 'fasttext.node', 'sentencepiece.node']
>>>>>>>
const nativeExtensions = [
'node_sqlite3.node',
'fse.node',
'crfsuite.node',
'fasttext.node',
'node-svm.node',
'sentencepiece.node'
]
<<<<<<<
return originalRequire.apply(this, (arguments as never) as [string])
=======
// @ts-ignore
return originalRequire.apply(this, arguments)
>>>>>>>
// @ts-ignore
return originalRequire.apply(this, (arguments as never) as [string]) |
<<<<<<<
const collection = await this.slotExtractor.extract(text, intentDef, entities)
const result: sdk.NLU.SlotCollection = {}
for (const name of Object.keys(collection)) {
if (Array.isArray(collection[name])) {
result[name] = _.orderBy(collection[name], ['confidence'], ['desc'])[0]
}
}
return result
=======
return await this.slotExtractor.extract(text, lang, intentDef, entities)
>>>>>>>
const collection = await this.slotExtractor.extract(text, lang, intentDef, entities)
const result: sdk.NLU.SlotCollection = {}
for (const name of Object.keys(collection)) {
if (Array.isArray(collection[name])) {
result[name] = _.orderBy(collection[name], ['confidence'], ['desc'])[0]
}
}
return result
<<<<<<<
const entities = await this._extractEntities(text, ret.language)
const entitiesToReplace = _.chain(entities)
.filter(x => x.type === 'pattern' || x.type === 'list')
.orderBy(['entity.meta.start', 'entity.meta.confidence'], ['asc', 'desc'])
.value()
let noEntitiesText = ''
let cursor = 0
for (const entity of entitiesToReplace) {
if (entity.meta.start < cursor) {
continue
}
noEntitiesText += text.substr(cursor, entity.meta.start - cursor) + entity.name
cursor = entity.meta.end
}
noEntitiesText += text.substr(cursor, text.length - cursor)
ret = { ...ret, ...(await this._extractIntents(text, noEntitiesText, ret.language, includedContexts)) }
ret.entities = entities
ret.slots = await this._extractSlots(text, ret.intent, entities)
=======
ret = { ...ret, ...(await this._extractIntents(text, includedContexts)) }
ret.entities = await this._extractEntities(text, ret.language)
ret.slots = await this._extractSlots(text, ret.language, ret.intent, ret.entities)
>>>>>>>
const entities = await this._extractEntities(text, ret.language)
const entitiesToReplace = _.chain(entities)
.filter(x => x.type === 'pattern' || x.type === 'list')
.orderBy(['entity.meta.start', 'entity.meta.confidence'], ['asc', 'desc'])
.value()
let noEntitiesText = ''
let cursor = 0
for (const entity of entitiesToReplace) {
if (entity.meta.start < cursor) {
continue
}
noEntitiesText += text.substr(cursor, entity.meta.start - cursor) + entity.name
cursor = entity.meta.end
}
noEntitiesText += text.substr(cursor, text.length - cursor)
ret = { ...ret, ...(await this._extractIntents(text, noEntitiesText, ret.language, includedContexts)) }
ret.entities = entities
ret.slots = await this._extractSlots(text, ret.language, ret.intent, entities) |
<<<<<<<
const { firstname, lastname, picture_url } = user.attributes
=======
const { type } = await this.authService.getStrategy(strategy)
const { firstname, lastname } = user.attributes
>>>>>>>
const { firstname, lastname, picture_url } = user.attributes
const { type } = await this.authService.getStrategy(strategy) |
<<<<<<<
import EntityService from './entities/entities-service'
=======
import { isOn as isAutoTrainOn, set as setAutoTrain } from './autoTrain'
import {
deleteEntity,
getCustomEntities,
getEntities,
getEntity,
saveEntity,
updateEntity
} from './entities/entities-service'
>>>>>>>
import { isOn as isAutoTrainOn, set as setAutoTrain } from './autoTrain'
import EntityService from './entities/entities-service' |
<<<<<<<
this.app.use(`${BASE_API_PATH}/sdk`, this.sdkApiRouter.router)
this.app.use(`/s`, this.shortlinksRouter.router)
=======
this.app.use(`/s`, this.shortLinksRouter.router)
>>>>>>>
this.app.use(`${BASE_API_PATH}/sdk`, this.sdkApiRouter.router)
this.app.use(`/s`, this.shortLinksRouter.router) |
<<<<<<<
allowStats: boolean
/**
* When this feature is enabled, fields saved as user attributes will be automatically erased when they expires. The timer is reset each time the value is modified
* Setting a policy called "email": "30d" means that once an email is set, it will be removed in 30 days, unless it is changed in that timespan
*/
dataRetention?: DataRetentionConfig
}
export interface DataRetentionConfig {
/**
* The janitor will check for expired fields at the set interval (second, minute, hour, day)
* @example 1m
*/
janitorInterval: string
policies: RetentionPolicy
}
/**
* @example "profile.email": "30d"
*/
export type RetentionPolicy = {
[key: string]: string
=======
sendUsageStats: boolean
>>>>>>>
sendUsageStats: boolean
/**
* When this feature is enabled, fields saved as user attributes will be automatically erased when they expires. The timer is reset each time the value is modified
* Setting a policy called "email": "30d" means that once an email is set, it will be removed in 30 days, unless it is changed in that timespan
*/
dataRetention?: DataRetentionConfig
}
export interface DataRetentionConfig {
/**
* The janitor will check for expired fields at the set interval (second, minute, hour, day)
* @example 1m
*/
janitorInterval: string
policies: RetentionPolicy
}
/**
* @example "profile.email": "30d"
*/
export type RetentionPolicy = {
[key: string]: string |
<<<<<<<
import Joi from 'joi'
import Knex from 'knex'
import _ from 'lodash'
import nanoid from 'nanoid'
=======
>>>>>>>
import Joi from 'joi'
import Knex from 'knex'
import _ from 'lodash'
import nanoid from 'nanoid'
<<<<<<<
import { AdminService } from './service'
=======
import CoreAdminService, { AdminService } from './professionnal/admin-service'
>>>>>>>
import { AdminService } from './service' |
<<<<<<<
export const getCacheKeyInMinutes = (minutes: number = 1) => Math.round(new Date().getTime() / 1000 / 60 / minutes)
/** Case-insensitive "startsWith" */
export const startsWithI = (a: string, b: string) => a.toLowerCase().startsWith(b.toLowerCase())
=======
export const getCacheKeyInMinutes = (minutes: number = 1) => Math.round(new Date().getTime() / 1000 / 60 / minutes)
export const asBytes = (size: string) => {
if (typeof size === 'number') return size
size = typeof size === 'string' ? size : '0'
const matches = size
.replace(',', '.')
.toLowerCase()
.match(/(\d+\.?\d{0,})\s{0,}(mb|gb|pt|kb|b)?/i)
if (!matches || !matches.length) {
return 0
}
/**/ if (matches[2] === 'b') return Number(matches[1]) * Math.pow(1024, 0)
else if (matches[2] === 'kb') return Number(matches[1]) * Math.pow(1024, 1)
else if (matches[2] === 'mb') return Number(matches[1]) * Math.pow(1024, 2)
else if (matches[2] === 'gb') return Number(matches[1]) * Math.pow(1024, 3)
else if (matches[2] === 'tb') return Number(matches[1]) * Math.pow(1024, 4)
return Number(matches[1])
}
>>>>>>>
export const getCacheKeyInMinutes = (minutes: number = 1) => Math.round(new Date().getTime() / 1000 / 60 / minutes)
/** Case-insensitive "startsWith" */
export const startsWithI = (a: string, b: string) => a.toLowerCase().startsWith(b.toLowerCase())
export const asBytes = (size: string) => {
if (typeof size === 'number') return size
size = typeof size === 'string' ? size : '0'
const matches = size
.replace(',', '.')
.toLowerCase()
.match(/(\d+\.?\d{0,})\s{0,}(mb|gb|pt|kb|b)?/i)
if (!matches || !matches.length) {
return 0
}
/**/ if (matches[2] === 'b') return Number(matches[1]) * Math.pow(1024, 0)
else if (matches[2] === 'kb') return Number(matches[1]) * Math.pow(1024, 1)
else if (matches[2] === 'mb') return Number(matches[1]) * Math.pow(1024, 2)
else if (matches[2] === 'gb') return Number(matches[1]) * Math.pow(1024, 3)
else if (matches[2] === 'tb') return Number(matches[1]) * Math.pow(1024, 4)
return Number(matches[1])
} |
<<<<<<<
export namespace kvs {
export function get(botId: string, key: string, path?: string): Promise<any>
export function set(botId: string, key: string, value: any, path?: string): Promise<void>
export function setStorageWithExpiry(botId: string, key: string, value, expiryInMs?: string | number)
export function getStorageWithExpiry(botId: string, key: string)
export function getConversationStorageKey(sessionId: string, variable: string): string
export function getUserStorageKey(userId: string, variable: string): string
export function getGlobalStorageKey(variable: string): string
}
=======
export namespace notifications {
export function create(botId: string, notification: Notification): Promise<any>
}
>>>>>>>
export namespace kvs {
export function get(botId: string, key: string, path?: string): Promise<any>
export function set(botId: string, key: string, value: any, path?: string): Promise<void>
export function setStorageWithExpiry(botId: string, key: string, value, expiryInMs?: string | number)
export function getStorageWithExpiry(botId: string, key: string)
export function getConversationStorageKey(sessionId: string, variable: string): string
export function getUserStorageKey(userId: string, variable: string): string
export function getGlobalStorageKey(variable: string): string
}
export namespace notifications {
export function create(botId: string, notification: Notification): Promise<any>
} |
<<<<<<<
import { DialogSessionTable, GhostFilesTable, GhostRevisionsTable, LogsTable } from './bot-specific'
=======
import { DialogSessionTable, LogsTable, NotificationsTable } from './bot-specific'
>>>>>>>
import { DialogSessionTable, GhostFilesTable, GhostRevisionsTable, LogsTable, NotificationsTable } from './bot-specific'
<<<<<<<
ChannelUsersTable,
DialogSessionTable,
GhostFilesTable,
GhostRevisionsTable
=======
DialogSessionTable,
NotificationsTable
>>>>>>>
ChannelUsersTable,
DialogSessionTable,
GhostFilesTable,
GhostRevisionsTable,
NotificationsTable |
<<<<<<<
app.post('/tokenize', waitForServiceMw, async (req, res, next) => {
=======
app.post('/vectorize', waitForServiceMw, validateLanguageMw, async (req, res, next) => {
>>>>>>>
app.post('/tokenize', waitForServiceMw, validateLanguageMw, async (req, res, next) => {
<<<<<<<
const result = await options.service.vectorize(tokens, lang)
res.json({ language: lang, vectors: result })
=======
const result = await options.service.vectorize(tokens, lang)
res.json({ input: tokens, language: lang, vectors: result })
>>>>>>>
const result = await options.service.vectorize(tokens, lang)
res.json({ language: lang, vectors: result }) |
<<<<<<<
import { extractListEntities, extractPatternEntities } from './entities/custom-entity-extractor'
import { BotCacheManager, getOrCreateCache } from './entities/entity-cache'
=======
import { extractListEntities, extractPatternEntities, mapE1toE2Entity } from './entities/custom-entity-extractor'
import { getSentenceEmbeddingForCtx } from './intents/context-classifier-featurizer'
>>>>>>>
import { extractListEntities, extractPatternEntities } from './entities/custom-entity-extractor'
import { getOrCreateCache } from './entities/entity-cache'
import { getSentenceEmbeddingForCtx } from './intents/context-classifier-featurizer' |
<<<<<<<
{ name: 'ml', fileExtensions: ['ml', 'ML', 'mlton', 'sig', 'fun', 'cm', 'lex', 'grm'] },
=======
{ name: 'capacitor', fileNames: ['capacitor.config.json'] },
{ name: 'sketch', fileExtensions: ['sketch'] },
{ name: 'adonis', fileNames: ['.adonisrc.json'] },
{
name: 'uml',
fileExtensions: ['iuml', 'pu', 'puml', 'plantuml', 'wsd'],
light: true,
},
{ name: 'meson', fileNames: ['meson.build'] },
{ name: 'buck', fileNames: ['.buckconfig'] },
>>>>>>>
{ name: 'capacitor', fileNames: ['capacitor.config.json'] },
{ name: 'sketch', fileExtensions: ['sketch'] },
{ name: 'adonis', fileNames: ['.adonisrc.json'] },
{
name: 'uml',
fileExtensions: ['iuml', 'pu', 'puml', 'plantuml', 'wsd'],
light: true,
},
{ name: 'meson', fileNames: ['meson.build'] },
{ name: 'buck', fileNames: ['.buckconfig'] },
{ name: 'ml', fileExtensions: ['ml', 'ML', 'mlton', 'sig', 'fun', 'cm', 'lex', 'grm'] }, |
<<<<<<<
/**
* Files starting with a dot are disabled. This prefix means it was automatically disabled and
* will be automatically re-enabled when the corresponding module is enabled in the future
*/
const DISABLED_PREFIX = '.__'
=======
interface ModuleMigrationInstruction {
/** exact name of the files to delete (path is relative to the migration file) */
filesToDelete: string[]
}
>>>>>>>
/**
* Files starting with a dot are disabled. This prefix means it was automatically disabled and
* will be automatically re-enabled when the corresponding module is enabled in the future
*/
const DISABLED_PREFIX = '.__'
interface ModuleMigrationInstruction {
/** exact name of the files to delete (path is relative to the migration file) */
filesToDelete: string[]
} |
<<<<<<<
const { utterance } = input
=======
const { utterance, alternateUtterance } = input
const sysEntities = (await tools.duckling.extract(utterance.toString(), utterance.languageCode)).map(mapE1toE2Entity)
>>>>>>>
const { utterance, alternateUtterance } = input |
<<<<<<<
{ name: 'folder-mobile', folderNames: ['mobile', 'mobiles', 'portable'] },
{ name: 'folder-terraform', folderNames: ['terraform'] },
=======
{ name: 'folder-mobile', folderNames: ['mobile', 'mobiles', 'portable', 'portability'] },
{ name: 'folder-stencil', folderNames: ['.stencil'] },
{ name: 'folder-firebase', folderNames: ['.firebase'] },
{ name: 'folder-svelte', folderNames: ['svelte'] },
{ name: 'folder-update', folderNames: ['update', 'updates', 'upgrade', 'upgrades'] },
{ name: 'folder-intellij', folderNames: ['.idea'], light: true },
{ name: 'folder-azure-pipelines', folderNames: ['.azure-pipelines', '.azure-pipelines-ci'] },
{ name: 'folder-mjml', folderNames: ['mjml'] },
>>>>>>>
{ name: 'folder-mobile', folderNames: ['mobile', 'mobiles', 'portable'] },
{ name: 'folder-terraform', folderNames: ['terraform'] },
{ name: 'folder-mobile', folderNames: ['mobile', 'mobiles', 'portable', 'portability'] },
{ name: 'folder-stencil', folderNames: ['.stencil'] },
{ name: 'folder-firebase', folderNames: ['.firebase'] },
{ name: 'folder-svelte', folderNames: ['svelte'] },
{ name: 'folder-update', folderNames: ['update', 'updates', 'upgrade', 'upgrades'] },
{ name: 'folder-intellij', folderNames: ['.idea'], light: true },
{ name: 'folder-azure-pipelines', folderNames: ['.azure-pipelines', '.azure-pipelines-ci'] },
{ name: 'folder-mjml', folderNames: ['mjml'] }, |
<<<<<<<
private readonly entityManager: EntityManager,
=======
@Inject(forwardRef(() => RoleService))
private readonly roleService: RoleService,
>>>>>>>
private readonly entityManager: EntityManager,
@Inject(forwardRef(() => RoleService))
private readonly roleService: RoleService, |
<<<<<<<
import { CertificateUserDTO } from '../dto/CertificateUserDTO';
import { CourseDTO } from 'src/CourseModule/dto';
=======
import { CourseDTO } from '../../CourseModule/dto';
>>>>>>>
import { CertificateUserDTO } from '../dto/CertificateUserDTO';
import { CourseDTO } from '../../CourseModule/dto'; |
<<<<<<<
$el: Dom7Array;
/** Gauge generated SVH HTML element */
svgEl: HTMLElement;
/** Dom7 instance with generated SVH HTML element */
$svgEl: Dom7Array;
=======
$el : Dom7Instance
/** Gauge generated SVG HTML element */
gaugeSvgEl : HTMLElement
/** Dom7 instance with generated SVG HTML element */
$gaugeSvgEl : Dom7Instance
>>>>>>>
$el: Dom7Array;
/** Gauge generated SVH HTML element */
svgEl: HTMLElement;
/** Dom7 instance with generated SVG HTML element */
$svgEl: Dom7Array; |
<<<<<<<
if (!isRelativeUrl(src) && !isSameOrigin(window.location.href, src)) {
img.crossOrigin = 'anonymous'
}
if (typeof image === 'string') {
img.src = src
}
return new Promise<ImageBase>((resolve, reject) => {
=======
return new Bluebird<ImageBase>((resolve, reject) => {
>>>>>>>
return new Promise<ImageBase>((resolve, reject) => { |
<<<<<<<
import { Injectable, Type } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
import { Observable } from 'rxjs';
=======
import { Injectable, Type, OnModuleDestroy } from '@nestjs/common';
import { Observable, Subscription } from 'rxjs';
>>>>>>>
import { Injectable, Type } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
import { Observable, Subscription } from 'rxjs';
<<<<<<<
export class EventBus extends ObservableBus<IEvent> implements IEventBus {
=======
export class EventBus extends ObservableBus<IEvent>
implements IEventBus, OnModuleDestroy {
private moduleRef = null;
>>>>>>>
export class EventBus extends ObservableBus<IEvent>
implements IEventBus, OnModuleDestroy {
<<<<<<<
set publisher(_publisher: IEventPublisher) {
this._publisher = _publisher;
=======
onModuleDestroy() {
this.subscriptions.forEach(subscription => subscription.unsubscribe());
}
setModuleRef(moduleRef) {
this.moduleRef = moduleRef;
>>>>>>>
set publisher(_publisher: IEventPublisher) {
this._publisher = _publisher;
}
onModuleDestroy() {
this.subscriptions.forEach(subscription => subscription.unsubscribe());
<<<<<<<
stream$
.pipe(filter(e => !!e))
=======
const subscription = stream$
.pipe(filter(e => e))
>>>>>>>
const subscription = stream$
.pipe(filter(e => !!e)) |
<<<<<<<
import { Metatype } from '@nestjs/common/interfaces';
import { Component } from '@nestjs/common';
import { Observable } from 'rxjs/Observable';
=======
import { Injectable, Type } from '@nestjs/common';
import { EventObservable } from './interfaces/event-observable.interface';
import { Observable } from 'rxjs';
>>>>>>>
import { Injectable, Type } from '@nestjs/common';
import { EventObservable } from './interfaces/event-observable.interface';
import { Observable } from 'rxjs';
<<<<<<<
import 'rxjs/add/operator/filter';
import {IEventPublisher} from "./interfaces/events/event-publisher.interface";
import {DefaultPubSub} from "./utils/default-pubsub";
=======
import { filter } from 'rxjs/operators';
>>>>>>>
import { filter } from 'rxjs/operators';
import { IEventPublisher } from './interfaces/events/event-publisher.interface';
import { DefaultPubSub } from './utils/default-pubsub';
<<<<<<<
get publisher(): IEventPublisher {
return this._publisher;
}
set publisher(thePublisher: IEventPublisher) {
this._publisher = thePublisher;
}
=======
stream$
.pipe(filter(e => e))
.subscribe(command => this.commandBus.execute(command));
}
private reflectEventsNames(
handler: EventHandlerMetatype,
): FunctionConstructor[] {
return Reflect.getMetadata(EVENTS_HANDLER_METADATA, handler);
}
>>>>>>>
stream$
.pipe(filter(e => e))
.subscribe(command => this.commandBus.execute(command));
}
private reflectEventsNames(
handler: EventHandlerMetatype,
): FunctionConstructor[] {
return Reflect.getMetadata(EVENTS_HANDLER_METADATA, handler);
}
get publisher(): IEventPublisher {
return this._publisher;
}
set publisher(thePublisher: IEventPublisher) {
this._publisher = thePublisher;
} |
<<<<<<<
green: 'rgb(76, 175, 80)',
info_background: '#5A91BB',
success_background: '#59A05E',
danger_background: '#CA4A34',
warning_background: '#D49538',
=======
green: '#5AC36F',
tab_border: '#4A90E2',
>>>>>>>
info_background: '#5A91BB',
success_background: '#59A05E',
danger_background: '#CA4A34',
warning_background: '#D49538',
green: '#5AC36F',
tab_border: '#4A90E2',
<<<<<<<
green: 'rgb(76, 175, 80)',
info_background: '#5A91BB',
success_background: '#59A05E',
danger_background: '#CA4A34',
warning_background: '#D49538',
=======
green: '#5AC36F',
tab_border: '#4A90E2',
>>>>>>>
info_background: '#5A91BB',
success_background: '#59A05E',
danger_background: '#CA4A34',
warning_background: '#D49538',
green: '#5AC36F',
tab_border: '#4A90E2', |
<<<<<<<
this.ignoreOnboarding = data[8][1] ? moment(data[8][1]) : false;
this.dataSaverMode = data[9][1] || false;
this.dataSaverModeDisablesOnWiFi = data[10][1] || false;
=======
this.ignoreOnboarding = data[8][1]
? moment(parseInt(data[8][1], 10))
: false;
>>>>>>>
this.ignoreOnboarding = data[8][1]
? moment(parseInt(data[8][1], 10))
: false;
this.dataSaverMode = data[9][1] || false;
this.dataSaverModeDisablesOnWiFi = data[10][1] || false; |
<<<<<<<
'IgnoreBestLanguage',
=======
'ComposerMode',
>>>>>>>
'IgnoreBestLanguage',
'ComposerMode',
<<<<<<<
this.ignoreBestLanguage = data[6][1] || '';
=======
this.composerMode = data[6][1] || 'photo';
>>>>>>>
this.ignoreBestLanguage = data[6][1] || '';
this.composerMode = data[7][1] || 'photo'; |
<<<<<<<
'DataSaverMode',
'DataSaverModeDisablesOnWiFi',
=======
'SwipeAnimShown',
>>>>>>>
'DataSaverMode',
'DataSaverModeDisablesOnWiFi',
'SwipeAnimShown', |
<<<<<<<
import { SwipeDirection } from "./swipe-direction";
import { Locator } from "./locators";
=======
import { Direction } from "./direction";
>>>>>>>
import { Direction } from "./direction";
import { Locator } from "./locators"; |
<<<<<<<
const collectionOption = options.find(option => option.name === 'collection' && option.value != null);
// @ts-ignore
const collectionName: any = collectionOption.value;
await generateApplicationFiles(
inputs,
options,
isDryRunEnabled as boolean,
collectionName,
).catch(exit);
=======
await askForMissingInformation(inputs);
await generateApplicationFiles(inputs, options).catch(exit);
>>>>>>>
await askForMissingInformation(inputs);
await generateApplicationFiles(inputs, options).catch(exit);
<<<<<<<
const generateApplicationFiles = async (
args: Input[],
options: Input[],
isDryRunEnabled: boolean,
collectionName: any,
) => {
=======
const generateApplicationFiles = async (args: Input[], options: Input[]) => {
>>>>>>>
const generateApplicationFiles = async (args: Input[], options: Input[]) => {
const collectionName = (options.find(option => option.name === 'collection' && option.value != null)).value;
<<<<<<<
if (!isDryRunEnabled) {
await generateConfigurationFile(args, options, collection, collectionName);
}
=======
>>>>>>>
<<<<<<<
const generateConfigurationFile = async (
args: Input[],
options: Input[],
collection: AbstractCollection,
collectionName: any,
) => {
const schematicOptions: SchematicOption[] = mapConfigurationSchematicOptions(
args.concat(options),
);
schematicOptions.push(
new SchematicOption('collection', collectionName),
);
await collection.execute('configuration', schematicOptions);
};
const mapConfigurationSchematicOptions = (
inputs: Input[],
): SchematicOption[] => {
return inputs.reduce(
(schematicsOptions: SchematicOption[], option: Input) => {
if (option.name === 'name') {
schematicsOptions.push(
new SchematicOption('project', dasherize(option.value as string)),
);
}
if (option.name === 'language') {
schematicsOptions.push(new SchematicOption(option.name, option.value));
}
return schematicsOptions;
},
[],
);
};
=======
>>>>>>> |
<<<<<<<
const recordAddresses = await this.getRecordsAddresses(domain);
if (!recordAddresses) return null;
const [ownerAddress, resolverAddress] = recordAddresses;
const resolution = await this.getResolverRecordsStructure(resolverAddress);
=======
const recordAddresses = await this._getRecordsAddresses(domain);
if (!recordAddresses) return null;
const [ownerAddress, resolverAddress] = recordAddresses;
const resolution = await this._getResolverRecordsStructure(resolverAddress);
>>>>>>>
const recordAddresses = await this._getRecordsAddresses(domain);
if (!recordAddresses) return null;
const [ownerAddress, resolverAddress] = recordAddresses;
const resolution = await this._getResolverRecordsStructure(resolverAddress);
<<<<<<<
async resolution(domain:string) : Promise<any | null> {
if (!this.isSupportedDomain(domain) || !this.isSupportedNetwork())
return null;
const recordAddresses = await this.getRecordsAddresses(domain);
if (!recordAddresses) return null;
const [ownerAddress, resolverAddress] = recordAddresses;
const resolution = await this.getResolverRecordsStructure(resolverAddress);
return {
resolution: _.omit(resolution, ['crypto']),
addresses: _.mapValues(resolution.crypto, 'address'),
meta: {
owner: ownerAddress || null,
type: 'zns',
ttl: parseInt(resolution.ttl as string) || 0
}
};
}
=======
/**
* Resolves a domain
* @param domain - domain name to be resolved
* @returns - Everything what is stored on specified domain
*/
async resolution(domain: string): Promise<Object | {}> {
if (!this.isSupportedDomain(domain) || !this.isSupportedNetwork())
return {};
const recordAddresses = await this._getRecordsAddresses(domain);
if (!recordAddresses) return {};
const [_, resolverAddress] = recordAddresses;
return await this._getResolverRecordsStructure(resolverAddress);
}
>>>>>>>
/**
* Resolves a domain
* @param domain - domain name to be resolved
* @returns - Everything what is stored on specified domain
*/
async resolution(domain: string): Promise<Object | {}> {
if (!this.isSupportedDomain(domain) || !this.isSupportedNetwork())
return {};
const recordAddresses = await this._getRecordsAddresses(domain);
if (!recordAddresses) return {};
const [_, resolverAddress] = recordAddresses;
return await this._getResolverRecordsStructure(resolverAddress);
}
<<<<<<<
namehash(domain: string): string {
return namehash(domain);
}
private async getRecordsAddresses(domain: string) : Promise<[string, string] | null> {
const registryRecord = await this.getContractMapValue(
this.registry,
'records',
namehash(domain),
);
if (!registryRecord) return null;
let [ownerAddress, resolverAddress] = registryRecord.arguments as [
string,
string
];
if (ownerAddress.startsWith('0x')) {
ownerAddress = toBech32Address(ownerAddress);
}
return [ownerAddress, resolverAddress];
}
=======
/**
* @ignore
* @param domain - domain name
*/
async _getRecordsAddresses(domain: string): Promise<[string, string] | null> {
const registryRecord = await this.getContractMapValue(
this.registry,
'records',
namehash(domain),
);
if (!registryRecord) return null;
let [ownerAddress, resolverAddress] = registryRecord.arguments as [
string,
string
];
if (ownerAddress.startsWith('0x')) {
ownerAddress = toBech32Address(ownerAddress);
}
return [ownerAddress, resolverAddress];
}
/**
* @ignore
* @param resolverAddress
*/
async _getResolverRecordsStructure(
resolverAddress: string,
): Promise<NamicornResolution | any> {
if (resolverAddress == NullAddress) {
return {};
}
const resolver = this.zilliqa.contracts.at(
toChecksumAddress(resolverAddress),
);
const resolverRecords = (await this.getContractField(
resolver,
'records',
)) as { [key: string]: string };
return _.transform(
resolverRecords,
(result, value, key) => _.set(result, key, value),
{},
);
}
>>>>>>>
namehash(domain: string): string {
return namehash(domain);
}
/**
* @ignore
* @param domain - domain name
*/
async _getRecordsAddresses(domain: string): Promise<[string, string] | null> {
const registryRecord = await this.getContractMapValue(
this.registry,
'records',
namehash(domain),
);
if (!registryRecord) return null;
let [ownerAddress, resolverAddress] = registryRecord.arguments as [
string,
string
];
if (ownerAddress.startsWith('0x')) {
ownerAddress = toBech32Address(ownerAddress);
}
return [ownerAddress, resolverAddress];
}
/**
* @ignore
* @param resolverAddress
*/
async _getResolverRecordsStructure(
resolverAddress: string,
): Promise<NamicornResolution | any> {
if (resolverAddress == NullAddress) {
return {};
}
const resolver = this.zilliqa.contracts.at(
toChecksumAddress(resolverAddress),
);
const resolverRecords = (await this.getContractField(
resolver,
'records',
)) as { [key: string]: string };
return _.transform(
resolverRecords,
(result, value, key) => _.set(result, key, value),
{},
);
} |
<<<<<<<
import { valueOrDefault, transformOrDefault } from '../utils/check';
=======
import { valueOrDefault } from '../utils/check';
import { StorageService } from '../services/storage';
>>>>>>>
import { valueOrDefault, transformOrDefault } from '../utils/check';
import { StorageService } from '../services/storage'; |
<<<<<<<
import { transformOrDefault } from '../utils/check';
import { CoinModel } from './coin';
import { WalletAddressModel } from './walletAddress';
=======
import { CoinStorage } from './coin';
import { WalletAddressStorage } from './walletAddress';
>>>>>>>
import { CoinStorage } from './coin';
import { transformOrDefault } from '../utils/check';
import { WalletAddressStorage } from './walletAddress';
<<<<<<<
import { valueOrDefault } from '../utils/check';
=======
import { Config } from '../services/config';
>>>>>>>
import { Config } from '../services/config';
import { valueOrDefault } from '../utils/check'; |
<<<<<<<
lite: boolean;
=======
tokens?: Array<any>;
>>>>>>>
lite: boolean;
tokens?: Array<any>;
<<<<<<<
xPubKey,
pubKey
=======
xPubKey: hdPrivKey.xpubkey,
pubKey,
tokens: []
>>>>>>>
xPubKey: hdPrivKey.xpubkey,
pubKey,
tokens: []
<<<<<<<
if (!lite) {
console.log(mnemonic.toString());
}
=======
console.log(mnemonic.toString());
>>>>>>>
if (!lite) {
console.log(mnemonic.toString());
} |
<<<<<<<
.option('-c, --config [path]', 'Path to nest-cli configuration file')
.option('-p, --path [path]', 'Path to tsconfig file')
.option('-w, --watch', 'Run in watch mode (live-reload)')
.option('--webpack', 'Use webpack for compilation')
.option('--webpackPath [path]', 'Path to webpack configuration')
.option('--tsc', 'Use tsc for compilation')
.description('Build Nest application')
=======
.option('-p, --path [path]', 'Path to tsconfig file.')
.option('-w, --watch', 'Run in watch mode (live-reload).')
.option('--webpack', 'Use webpack for compilation.')
.option('--webpackPath [path]', 'Path to webpack configuration.')
.description('Build Nest application.')
>>>>>>>
.option('-c, --config [path]', 'Path to nest-cli configuration file.')
.option('-p, --path [path]', 'Path to tsconfig file.')
.option('-w, --watch', 'Run in watch mode (live-reload).')
.option('--webpack', 'Use webpack for compilation.')
.option('--webpackPath [path]', 'Path to webpack configuration.')
.option('--tsc', 'Use tsc for compilation.')
.description('Build Nest application.') |
<<<<<<<
=======
async getWalletAddresses(walletId: ObjectID) {
let query = { chain: this.chain, wallet: walletId };
return WalletAddressStorage.collection
.find(query)
.addCursorFlag('noCursorTimeout', true)
.toArray();
}
>>>>>>> |
<<<<<<<
import { Component, EventEmitter, Injectable, Input, Output } from '@angular/core';
import { Http } from '@angular/http';
=======
import { Component, EventEmitter, Input, Output } from '@angular/core';
>>>>>>>
import { Component, EventEmitter, Injectable, Input, Output } from '@angular/core';
<<<<<<<
import { ActionSheetController, NavController, PopoverController, ToastController } from 'ionic-angular';
import { App } from 'ionic-angular/components/app/app';
import { Logger } from '../../providers/logger/logger';
=======
import { ActionSheetController, App, NavController, PopoverController, ToastController } from 'ionic-angular';
import * as _ from 'lodash';
>>>>>>>
import { ActionSheetController, App, NavController, PopoverController, ToastController } from 'ionic-angular';
import { Logger } from '../../providers/logger/logger';
import * as _ from 'lodash';
<<<<<<<
@Injectable()
=======
>>>>>>>
@Injectable()
<<<<<<<
public toastCtrl: ToastController,
private logger: Logger,
=======
public toastCtrl: ToastController,
public searchProvider: SearchProvider,
public redirProvider: RedirProvider
>>>>>>>
public toastCtrl: ToastController,
private logger: Logger,
public searchProvider: SearchProvider,
public redirProvider: RedirProvider
<<<<<<<
if (this.isInputValid(this.q)) {
this.http.get(apiPrefix + '/block/' + this.q).subscribe(
(data: any): void => {
this.resetSearch();
const parsedData: any = JSON.parse(data._body);
this.logger.info(parsedData);
this.navCtrl.push('block-detail', {
chain: this.apiProvider.networkSettings.value.selectedNetwork.chain,
network: this.apiProvider.networkSettings.value.selectedNetwork
.network,
blockHash: parsedData.hash
=======
const inputDetails = this.searchProvider.isInputValid(this.q);
if (this.q !== '' && inputDetails.isValid) {
this.searchProvider.search(this.q, inputDetails.type).subscribe(res => {
if (_.isArray(res)) {
const index = _.findIndex(res, (o) => {
return o !== null;
>>>>>>>
const inputDetails = this.searchProvider.isInputValid(this.q);
if (this.q !== '' && inputDetails.isValid) {
this.searchProvider.search(this.q, inputDetails.type).subscribe(res => {
if (_.isArray(res)) {
const index = _.findIndex(res, (o) => {
return o !== null;
<<<<<<<
},
() => {
this.http.get(apiPrefix + '/tx/' + this.q).subscribe(
(data: any): void => {
this.resetSearch();
const parsedData: any = JSON.parse(data._body);
this.logger.info(parsedData);
this.navCtrl.push('transaction', {
chain: this.apiProvider.networkSettings.value.selectedNetwork
.chain,
network: this.apiProvider.networkSettings.value.selectedNetwork
.network,
txId: parsedData.txid
});
},
() => {
this.http.get(apiPrefix + '/address/' + this.q).subscribe(
(data: any): void => {
const addrStr = this.q;
this.resetSearch();
const parsedData: any = JSON.parse(data._body);
this.logger.info(parsedData);
this.navCtrl.push('address', {
chain: this.apiProvider.networkSettings.value.selectedNetwork
.chain,
network: this.apiProvider.networkSettings.value
.selectedNetwork.network,
addrStr
});
},
() => {
this.loading = false;
this.reportBadQuery();
}
);
}
);
=======
if (index === 0) {
this.redirTo = 'block-detail';
this.params = res[0].json().hash;
} else {
this.redirTo = 'transaction';
this.params = res[1].json().txid;
}
} else {
this.redirTo = 'address';
this.params = res.json()[0].address;
>>>>>>>
if (index === 0) {
this.redirTo = 'block-detail';
this.params = res[0].json().hash;
} else {
this.redirTo = 'transaction';
this.params = res[1].json().txid;
}
} else {
this.redirTo = 'address';
this.params = res.json()[0].address; |
<<<<<<<
import { TransactionJSON } from '../../../types/Transaction';
import { IBlock } from '../../../models/baseBlock';
=======
import { Validation } from 'crypto-wallet-core';
>>>>>>>
import { Validation } from 'crypto-wallet-core';
import { TransactionJSON } from '../../../types/Transaction';
import { IBlock } from '../../../models/baseBlock'; |
<<<<<<<
it('should build a test pipe file name', () => {
expect(
builder
.addName('name')
.addAsset(AssetEnum.PIPE)
.addTest(false)
.addExtension('ts')
.build()
).to.be.equal('name.pipe.ts');
});
=======
it('should builder a middleware file name', () => {
expect(
builder
.addName('name')
.addAsset(AssetEnum.MIDDLEWARE)
.addTest(false)
.addExtension('ts')
.build()
).to.be.equal('name.middleware.ts');
});
>>>>>>>
it('should build a pipe file name', () => {
expect(
builder
.addName('name')
.addAsset(AssetEnum.PIPE)
.addTest(false)
.addExtension('ts')
.build()
).to.be.equal('name.pipe.ts');
});
it('should builder a middleware file name', () => {
expect(
builder
.addName('name')
.addAsset(AssetEnum.MIDDLEWARE)
.addTest(false)
.addExtension('ts')
.build()
).to.be.equal('name.middleware.ts');
}); |
<<<<<<<
baseUrl = baseUrl || '/v5/txproposals/';
=======
// baseUrl = baseUrl || '/v4/txproposals/'; // DISABLED 2020-04-07
baseUrl = '/v3/txproposals/';
>>>>>>>
baseUrl = baseUrl || '/v4/txproposals/';
// baseUrl = baseUrl || '/v4/txproposals/'; // DISABLED 2020-04-07
<<<<<<<
base = base || '/v3/txproposals/';
=======
// base = base || '/v2/txproposals/'; // DISABLED 2020-04-07
base = '/v1/txproposals/';
>>>>>>>
base = base || '/v4/txproposals/';
// base = base || '/v2/txproposals/'; // DISABLED 2020-04-07 |
<<<<<<<
private async requestWithParams({
method,
path,
payload,
urlParams,
queryParams,
catchNotFound,
payloadKey,
}: {
method: string;
path: string;
payload: any;
urlParams: any;
queryParams?: Record<string, any> | null;
catchNotFound: boolean;
payloadKey?: string;
}) {
const newPath = join(this.basePath, path);
=======
private async requestWithParams(
{
method,
path,
payload,
urlParams,
queryParams,
catchNotFound,
payloadKey
}:
{
method: string,
path: string,
payload: any,
urlParams: any,
queryParams?: Record<string, any> | null,
catchNotFound: boolean,
payloadKey?: string
}) {
const newPath = urlJoin(this.basePath, path);
>>>>>>>
private async requestWithParams({
method,
path,
payload,
urlParams,
queryParams,
catchNotFound,
payloadKey,
}: {
method: string;
path: string;
payload: any;
urlParams: any;
queryParams?: Record<string, any> | null;
catchNotFound: boolean;
payloadKey?: string;
}) {
const newPath = urlJoin(this.basePath, path); |
<<<<<<<
public getSessionCount = this.makeRequest<{id: string}, {count: number}>({
=======
public getSessionCount = this.makeRequest<
{id: string},
{'count': number}
>({
>>>>>>>
public getSessionCount = this.makeRequest<{id: string}, {count: number}>({
<<<<<<<
public getOfflineSessionCount = this.makeRequest<{id: string}, {count: number}>({
=======
/**
* Policy
*/
public findByName = this.makeRequest<
{id: string, name: string},
PolicyRepresentation
>({
method: 'GET',
path: '{id}/authz/resource-server/policy/search',
urlParamKeys: ['id'],
});
public updatePolicy = this.makeUpdateRequest<
{id: string; type: string; policyId: string},
PolicyRepresentation,
void
>({
method: 'PUT',
path: '/{id}/authz/resource-server/policy/{type}/{policyId}',
urlParamKeys: ['id', 'type', 'policyId'],
});
public createPolicy = this.makeUpdateRequest<
{id: string, type: string},
PolicyRepresentation,
PolicyRepresentation
>({
method: 'POST',
path: '/{id}/authz/resource-server/policy/{type}',
urlParamKeys: ['id', 'type'],
});
public findOnePolicy = this.makeRequest<
{id: string; type: string; policyId: string},
void
>({
method: 'GET',
path: '/{id}/authz/resource-server/policy/{type}/{policyId}',
urlParamKeys: ['id', 'type', 'policyId'],
catchNotFound: true,
});
public delPolicy = this.makeRequest<
{id: string, policyId: string},
void
>({
method: 'Delete',
path: '{id}/authz/resource-server/policy/{policyId}',
urlParamKeys: ['id', 'policyId'],
});
public async createOrUpdatePolicy(
payload: {id: string; policyName: string; policy: PolicyRepresentation}
): Promise<PolicyRepresentation> {
const policyFound = await this.findByName({id: payload.id, name: payload.policyName});
if (policyFound) {
await this.updatePolicy({id: payload.id, policyId: policyFound.id, type: payload.policy.type}, payload.policy);
return this.findByName({id: payload.id, name: payload.policyName});
} else {
return this.createPolicy({id: payload.id, type: payload.policy.type}, payload.policy);
}
}
/**
* Scopes
*/
public listScopesByResource = this.makeRequest<
{id: string, resourceName: string},
{id: string, name: string}[]
>({
method: 'GET',
path: '/{id}/authz/resource-server/resource/{resourceName}/scopes',
urlParamKeys: ['id', 'resourceName'],
});
/**
* Permissions
*/
public createPermission = this.makeRequest<
PolicyRepresentation,
{id: string; type: string}
>({
method: 'POST',
path: '/{id}/authz/resource-server/permission/{type}',
urlParamKeys: ['id', 'type'],
});
public updatePermission = this.makeUpdateRequest<
{id: string; type: string; permissionId: string},
PolicyRepresentation,
void
>({
method: 'PUT',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public delPermission = this.makeRequest<
{id: string; type: string; permissionId: string},
void
>({
method: 'DELETE',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public findOnePermission = this.makeRequest<
{id: string; type: string; permissionId: string},
PolicyRepresentation
>({
method: 'GET',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public getOfflineSessionCount = this.makeRequest<
{id: string},
{"count": number}
>({
>>>>>>>
/**
* Policy
*/
public findByName = this.makeRequest<
{id: string, name: string},
PolicyRepresentation
>({
method: 'GET',
path: '{id}/authz/resource-server/policy/search',
urlParamKeys: ['id'],
});
public updatePolicy = this.makeUpdateRequest<
{id: string; type: string; policyId: string},
PolicyRepresentation,
void
>({
method: 'PUT',
path: '/{id}/authz/resource-server/policy/{type}/{policyId}',
urlParamKeys: ['id', 'type', 'policyId'],
});
public createPolicy = this.makeUpdateRequest<
{id: string, type: string},
PolicyRepresentation,
PolicyRepresentation
>({
method: 'POST',
path: '/{id}/authz/resource-server/policy/{type}',
urlParamKeys: ['id', 'type'],
});
public findOnePolicy = this.makeRequest<
{id: string; type: string; policyId: string},
void
>({
method: 'GET',
path: '/{id}/authz/resource-server/policy/{type}/{policyId}',
urlParamKeys: ['id', 'type', 'policyId'],
catchNotFound: true,
});
public delPolicy = this.makeRequest<
{id: string, policyId: string},
void
>({
method: 'DELETE',
path: '{id}/authz/resource-server/policy/{policyId}',
urlParamKeys: ['id', 'policyId'],
});
public async createOrUpdatePolicy(
payload: {id: string; policyName: string; policy: PolicyRepresentation}
): Promise<PolicyRepresentation> {
const policyFound = await this.findByName({id: payload.id, name: payload.policyName});
if (policyFound) {
await this.updatePolicy({id: payload.id, policyId: policyFound.id, type: payload.policy.type}, payload.policy);
return this.findByName({id: payload.id, name: payload.policyName});
} else {
return this.createPolicy({id: payload.id, type: payload.policy.type}, payload.policy);
}
}
/**
* Scopes
*/
public listScopesByResource = this.makeRequest<
{id: string, resourceName: string},
{id: string, name: string}[]
>({
method: 'GET',
path: '/{id}/authz/resource-server/resource/{resourceName}/scopes',
urlParamKeys: ['id', 'resourceName'],
});
/**
* Permissions
*/
public createPermission = this.makeRequest<
PolicyRepresentation,
{id: string; type: string}
>({
method: 'POST',
path: '/{id}/authz/resource-server/permission/{type}',
urlParamKeys: ['id', 'type'],
});
public updatePermission = this.makeUpdateRequest<
{id: string; type: string; permissionId: string},
PolicyRepresentation,
void
>({
method: 'PUT',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public delPermission = this.makeRequest<
{id: string; type: string; permissionId: string},
void
>({
method: 'DELETE',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public findOnePermission = this.makeRequest<
{id: string; type: string; permissionId: string},
PolicyRepresentation
>({
method: 'GET',
path: '/{id}/authz/resource-server/permission/{type}/{permissionId}',
urlParamKeys: ['id', 'type', 'permissionId'],
});
public getOfflineSessionCount = this.makeRequest<{id: string}, {count: number}>({ |
<<<<<<<
import { sleep, getWaitForFn, nextIdle } from '../../core/utils';
import { mergeScreenshotOptions } from '../../screenshot-options';
import { hoc } from './hoc';
=======
import { sleep } from '../../core/utils';
>>>>>>>
import { getWaitForFn, nextIdle, sleep } from '../../core/utils';
<<<<<<<
const withScreenshot = (options: PartialScreenshotOptions = {}) => {
const { delay, waitFor, viewport, knobs, namespace } = mergeScreenshotOptions(options);
=======
export const withScreenshot = (options: PartialScreenshotOptions = {}) => {
const { delay, viewport, knobs, namespace } = mergeScreenshotOptions(options);
>>>>>>>
export const withScreenshot = (options: PartialScreenshotOptions = {}) => {
const { delay, waitFor, viewport, knobs, namespace } = mergeScreenshotOptions(options); |
<<<<<<<
import { UseractivityListComponent } from './modules/useractivity/useractivity-list/useractivity-list.component';
=======
import { SwitchupdatemodalComponent } from './common/components/switchupdatemodal/switchupdatemodal.component';
>>>>>>>
import { UseractivityListComponent } from './modules/useractivity/useractivity-list/useractivity-list.component';
import { SwitchupdatemodalComponent } from './common/components/switchupdatemodal/switchupdatemodal.component';
<<<<<<<
UseractivityListComponent,
=======
SwitchupdatemodalComponent,
>>>>>>>
UseractivityListComponent,
SwitchupdatemodalComponent, |
<<<<<<<
onCustomRender?: (field: ICustomCollectionField, value: any, onUpdate: (fieldId: string, value: any) => void, item: any) => JSX.Element;
=======
onCustomRender?: (field: ICustomCollectionField, value: any, onUpdate: (fieldId: string, value: any) => void, rowUniqueId: string) => JSX.Element;
>>>>>>>
onCustomRender?: (field: ICustomCollectionField, value: any, onUpdate: (fieldId: string, value: any) => void, item: any, rowUniqueId: string) => JSX.Element; |
<<<<<<<
import { PropertyFieldSliderWithCallout } from '../../PropertyFieldSliderWithCallout';
import { PropertyFieldChoiceGroupWithCallout } from '../../PropertyFieldChoiceGroupWithCallout';
=======
import { PropertyFieldButtonWithCallout } from '../../PropertyFieldButtonWithCallout';
import { PropertyFieldCheckboxWithCallout } from '../../PropertyFieldCheckboxWithCallout';
import { PropertyFieldLabelWithCallout } from '../../PropertyFieldLabelWithCallout';
import { PropertyFieldLinkWithCallout } from '../../PropertyFieldLinkWithCallout';
>>>>>>>
import { PropertyFieldSliderWithCallout } from '../../PropertyFieldSliderWithCallout';
import { PropertyFieldChoiceGroupWithCallout } from '../../PropertyFieldChoiceGroupWithCallout';
import { PropertyFieldButtonWithCallout } from '../../PropertyFieldButtonWithCallout';
import { PropertyFieldCheckboxWithCallout } from '../../PropertyFieldCheckboxWithCallout';
import { PropertyFieldLabelWithCallout } from '../../PropertyFieldLabelWithCallout';
import { PropertyFieldLinkWithCallout } from '../../PropertyFieldLinkWithCallout';
<<<<<<<
dropdownWithCalloutKey: this.properties.dropdownWithCalloutKey,
textWithCalloutValue: this.properties.textWithCalloutValue,
toggleWithCalloutValue: this.properties.toggleWithCalloutValue,
sliderWithCalloutValue: this.properties.sliderWithCalloutValue,
choiceGroupWithCalloutValue: this.properties.choiceGroupWithCalloutValue
=======
dropdownInfoHeaderKey: this.properties.dropdownInfoHeaderKey,
textInfoHeaderValue: this.properties.textInfoHeaderValue,
toggleInfoHeaderValue: this.properties.toggleInfoHeaderValue,
checkboxWithCalloutValue: this.properties.checkboxWithCalloutValue
>>>>>>>
dropdownWithCalloutKey: this.properties.dropdownWithCalloutKey,
textWithCalloutValue: this.properties.textWithCalloutValue,
toggleWithCalloutValue: this.properties.toggleWithCalloutValue,
sliderWithCalloutValue: this.properties.sliderWithCalloutValue,
choiceGroupWithCalloutValue: this.properties.choiceGroupWithCalloutValue
dropdownInfoHeaderKey: this.properties.dropdownInfoHeaderKey,
textInfoHeaderValue: this.properties.textInfoHeaderValue,
toggleInfoHeaderValue: this.properties.toggleInfoHeaderValue,
checkboxWithCalloutValue: this.properties.checkboxWithCalloutValue
<<<<<<<
checked: this.properties.toggleWithCalloutValue
}),
PropertyFieldSliderWithCallout('sliderWithCalloutValue', {
calloutContent: React.createElement('div', {}, 'Enter value for the item'),
calloutTrigger: CalloutTriggers.Click,
calloutWidth: 200,
key: 'sliderWithCalloutFieldId',
label: 'Slide to select the value',
max: 100,
min: 0,
step: 1,
showValue: true,
value: this.properties.sliderWithCalloutValue
}),
PropertyFieldChoiceGroupWithCallout('choiceGroupWithCalloutValue', {
calloutContent: React.createElement('div', {}, 'Select preferrable mobile platform'),
calloutTrigger: CalloutTriggers.Hover,
key: 'choiceGroupWithCalloutFieldId',
label: 'Preferred mobile platform',
options: [{
key: 'iOS',
text: 'iOS',
checked: this.properties.choiceGroupWithCalloutValue === 'iOS'
}, {
key: 'Android',
text: 'Android',
checked: this.properties.choiceGroupWithCalloutValue === 'Android'
}, {
key: 'Other',
text: 'Other',
checked: this.properties.choiceGroupWithCalloutValue === 'Other'
}]
=======
checked: this.properties.toggleInfoHeaderValue
}),
PropertyFieldButtonWithCallout('fakeProperty', {
calloutTrigger: CalloutTriggers.Click,
key: 'buttonWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Tests connection to the database with the parameters listed above'),
calloutWidth: 150,
text: 'Test connection',
onClick: () => { alert('Code to test connection goes here') }
}),
PropertyFieldCheckboxWithCallout('checkboxWithCalloutValue', {
calloutTrigger: CalloutTriggers.Click,
key: 'checkboxWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Check the checkbox to accept Application Terms and Conditions'),
calloutWidth: 200,
text: 'Accept terms and conditions',
checked: this.properties.checkboxWithCalloutValue
}),
PropertyFieldLabelWithCallout('fakeProp', {
calloutTrigger: CalloutTriggers.Click,
key: 'LabelWithCalloutFieldId',
calloutContent: 'Use dropdowns below to select list and list\'s field to work with',
calloutWidth: 200,
text: 'Select List and Field'
}),
PropertyFieldLinkWithCallout('fakeProp', {
calloutTrigger: CalloutTriggers.Click,
key: 'linkWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Click the link to open a new page with Application Terms & Conditions'),
calloutWidth: 200,
text: 'Terms & Conditions',
href: 'https://github.com/SharePoint/sp-dev-fx-property-controls',
target: '_blank'
>>>>>>>
checked: this.properties.toggleWithCalloutValue
}),
PropertyFieldSliderWithCallout('sliderWithCalloutValue', {
calloutContent: React.createElement('div', {}, 'Enter value for the item'),
calloutTrigger: CalloutTriggers.Click,
calloutWidth: 200,
key: 'sliderWithCalloutFieldId',
label: 'Slide to select the value',
max: 100,
min: 0,
step: 1,
showValue: true,
value: this.properties.sliderWithCalloutValue
}),
PropertyFieldChoiceGroupWithCallout('choiceGroupWithCalloutValue', {
calloutContent: React.createElement('div', {}, 'Select preferrable mobile platform'),
calloutTrigger: CalloutTriggers.Hover,
key: 'choiceGroupWithCalloutFieldId',
label: 'Preferred mobile platform',
options: [{
key: 'iOS',
text: 'iOS',
checked: this.properties.choiceGroupWithCalloutValue === 'iOS'
}, {
key: 'Android',
text: 'Android',
checked: this.properties.choiceGroupWithCalloutValue === 'Android'
}, {
key: 'Other',
text: 'Other',
checked: this.properties.choiceGroupWithCalloutValue === 'Other'
}]
checked: this.properties.toggleInfoHeaderValue
}),
PropertyFieldButtonWithCallout('fakeProperty', {
calloutTrigger: CalloutTriggers.Click,
key: 'buttonWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Tests connection to the database with the parameters listed above'),
calloutWidth: 150,
text: 'Test connection',
onClick: () => { alert('Code to test connection goes here') }
}),
PropertyFieldCheckboxWithCallout('checkboxWithCalloutValue', {
calloutTrigger: CalloutTriggers.Click,
key: 'checkboxWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Check the checkbox to accept Application Terms and Conditions'),
calloutWidth: 200,
text: 'Accept terms and conditions',
checked: this.properties.checkboxWithCalloutValue
}),
PropertyFieldLabelWithCallout('fakeProp', {
calloutTrigger: CalloutTriggers.Click,
key: 'LabelWithCalloutFieldId',
calloutContent: 'Use dropdowns below to select list and list\'s field to work with',
calloutWidth: 200,
text: 'Select List and Field'
}),
PropertyFieldLinkWithCallout('fakeProp', {
calloutTrigger: CalloutTriggers.Click,
key: 'linkWithCalloutFieldId',
calloutContent: React.createElement('p', {}, 'Click the link to open a new page with Application Terms & Conditions'),
calloutWidth: 200,
text: 'Terms & Conditions',
href: 'https://github.com/SharePoint/sp-dev-fx-property-controls',
target: '_blank' |
<<<<<<<
import { ZabbixMetricsQuery } from './types';
=======
import * as c from './constants';
>>>>>>>
import { ZabbixMetricsQuery } from './types';
import * as c from './constants'; |
<<<<<<<
type ThunkAction = (dispatch: Redux.Dispatch, getState: () => State) => void;
=======
export interface Action {
type: symbol;
item?: Item;
items?: Item[];
text?: string;
msg_kind?: MessageKind;
tweet_id?: string;
status?: Tweet;
statuses?: Tweet[];
user?: TwitterUser;
user_json?: Twitter.User;
editor?: EditorState;
in_reply_to_id?: string;
query?: string;
left?: number;
top?: number;
timeline?: TimelineKind;
mentions?: Tweet[];
completion_label?: AutoCompleteLabel;
suggestions?: SuggestionItem[];
ids?: number[];
index?: number;
media_urls?: string[];
user_id?: number;
}
type ThunkAction = (dispatch: Dispatch, getState: () => State) => void;
>>>>>>>
type ThunkAction = (dispatch: Dispatch, getState: () => State) => void; |
<<<<<<<
import { Engine, PhotonError, PhotonQueryError, QueryEngineError } from './Engine'
import got, { Got } from 'got'
=======
import { Engine, PrismaClientError, PrismaClientQueryError, QueryEngineError } from './Engine'
import got from 'got'
>>>>>>>
import { Engine, PrismaClientError, PrismaClientQueryError, QueryEngineError } from './Engine'
import got, { Got } from 'got'
<<<<<<<
private got: Got
=======
private logQueries: boolean
private logLevel?: 'info' | 'warn'
>>>>>>>
private logQueries: boolean
private logLevel?: 'info' | 'warn'
private got: Got
<<<<<<<
this.got = got.extend({
responseType: 'json',
headers: {
'Content-Type': 'application/json',
},
protocol: 'http:',
agent: this.keepaliveAgent,
});
=======
this.logLevel = logLevel
this.logQueries = logQueries || false
>>>>>>>
this.logLevel = logLevel
this.logQueries = logQueries || false
this.got = got.extend({
responseType: 'json',
headers: {
'Content-Type': 'application/json',
},
protocol: 'http:',
agent: this.keepaliveAgent,
});
<<<<<<<
collectTimestamps && collectTimestamps.record("Pre-engine_request_http_got")
this.currentRequestPromise = this.got.post(this.url, {
json: { query, variables: {} },
=======
collectTimestamps && collectTimestamps.record('Pre-engine_request_http_got')
this.currentRequestPromise = got.post(this.url, {
json: true,
headers: {
'Content-Type': 'application/json',
},
body: { query, variables: {} },
agent: this.keepaliveAgent,
>>>>>>>
collectTimestamps && collectTimestamps.record("Pre-engine_request_http_got")
this.currentRequestPromise = this.got.post(this.url, {
json: { query, variables: {} }, |
<<<<<<<
function getModules(targetPath: string): Module[] {
=======
function walk(dir: string, recursive: boolean): string[] {
/* Source: http://stackoverflow.com/a/5827895 */
let results: string[] = [];
let list = readdirSync(dir);
let i = 0;
(function next() {
let file = list[i++];
if (!file) {
return results;
}
file = dir + '\\' + file;
let stat = statSync(file);
if (stat && stat.isDirectory()) {
if (recursive) {
results = results.concat(walk(file, recursive));
next();
}
} else {
results.push(file);
next();
}
})();
return results;
}
function getfiles(targetPath: string, recursive: boolean): string[] {
>>>>>>>
function walk(dir: string, recursive: boolean): string[] {
/* Source: http://stackoverflow.com/a/5827895 */
let results: string[] = [];
let list = readdirSync(dir);
let i = 0;
(function next() {
let file = list[i++];
if (!file) {
return results;
}
file = dir + '/' + file;
let stat = statSync(file);
if (stat && stat.isDirectory()) {
if (recursive) {
results = results.concat(walk(file, recursive));
next();
}
} else {
results.push(file);
next();
}
})();
return results;
}
function getFiles(targetPath: string, recursive: boolean): string[] {
<<<<<<<
console.log("Found " + modules.length + " module(s)");
=======
>>>>>>>
console.log("Found " + modules.length + " module(s)"); |
<<<<<<<
@observable notificationListAnchor: null | HTMLElement = null;
@observable notificationList: Notification[] = [];
@action
setNotificationList(list: Notification[]) {
this.notificationList = list;
}
@action
setNotificationListAnchor(el: HTMLElement | null) {
this.notificationListAnchor = el;
}
=======
@observable initated: boolean = false;
@observable itemTableFilterText: string = '';
>>>>>>>
@observable notificationListAnchor: null | HTMLElement = null;
@observable notificationList: Notification[] = [];
@observable initated: boolean = false;
@observable itemTableFilterText: string = '';
@action
setNotificationList(list: Notification[]) {
this.notificationList = list;
}
@action
setNotificationListAnchor(el: HTMLElement | null) {
this.notificationListAnchor = el;
} |
<<<<<<<
@prototypeValue(Mixin([ CalculationSync, Quark, Map ], IdentityMixin<CalculationSync & Quark & Map<any, any>>()))
=======
@prototypeValue(true)
sync : boolean
@prototypeValue(buildClass(Map, CalculationSync, Quark))
>>>>>>>
@prototypeValue(true)
sync : boolean
@prototypeValue(Mixin([ CalculationSync, Quark, Map ], IdentityMixin<CalculationSync & Quark & Map<any, any>>()))
<<<<<<<
@prototypeValue(Mixin([ CalculationGen, Quark, Map ], IdentityMixin<CalculationGen & Quark & Map<any, any>>()))
=======
@prototypeValue(false)
sync : boolean
@prototypeValue(buildClass(Map, CalculationGen, Quark))
>>>>>>>
@prototypeValue(false)
sync : boolean
@prototypeValue(Mixin([ CalculationGen, Quark, Map ], IdentityMixin<CalculationGen & Quark & Map<any, any>>()))
<<<<<<<
@prototypeValue(Mixin([ CalculationSync, Quark, Map ], IdentityMixin<CalculationSync & Quark & Map<any, any>>()))
=======
@prototypeValue(true)
sync : boolean
@prototypeValue(buildClass(Map, CalculationSync, Quark))
>>>>>>>
@prototypeValue(true)
sync : boolean
@prototypeValue(Mixin([ CalculationSync, Quark, Map ], IdentityMixin<CalculationSync & Quark & Map<any, any>>()))
<<<<<<<
@prototypeValue(Mixin([ CalculationGen, Quark, Map ], IdentityMixin<CalculationGen & Quark & Map<any, any>>()))
=======
@prototypeValue(false)
sync : boolean
@prototypeValue(buildClass(Map, CalculationGen, Quark))
>>>>>>>
@prototypeValue(false)
sync : boolean
@prototypeValue(Mixin([ CalculationGen, Quark, Map ], IdentityMixin<CalculationGen & Quark & Map<any, any>>())) |
<<<<<<<
import { Base } from "../class/BetterMixin.js"
=======
import { AnyConstructor, Base, Mixin } from "../class/Mixin.js"
import { DEBUG } from "../environment/Debug.js"
import { cycleInfo, OnCycleAction, WalkStep } from "../graph/WalkDepth.js"
>>>>>>>
import { Base } from "../class/BetterMixin.js"
import { DEBUG } from "../environment/Debug.js"
import { cycleInfo, OnCycleAction, WalkStep } from "../graph/WalkDepth.js"
<<<<<<<
import { Checkout, PropagateArguments } from "./Checkout.js"
=======
import { CheckoutI, CommitArguments } from "./Checkout.js"
>>>>>>>
import { Checkout, CommitArguments } from "./Checkout.js"
<<<<<<<
import { Revision, Scope } from "./Revision.js"
=======
import { MinimalRevision, Revision, Scope } from "./Revision.js"
import { ComputationCycle, TransactionCycleDetectionWalkContext } from "./TransactionCycleDetectionWalkContext.js"
>>>>>>>
import { Revision, Scope } from "./Revision.js"
import { ComputationCycle, TransactionCycleDetectionWalkContext } from "./TransactionCycleDetectionWalkContext.js" |
<<<<<<<
import { Base } from "../../src/class/BetterMixin.js"
=======
import { ProposedOrCurrent } from "../../src/chrono/Effect.js"
import { Base } from "../../src/class/Mixin.js"
>>>>>>>
import { ProposedOrCurrent } from "../../src/chrono/Effect.js"
import { Base } from "../../src/class/BetterMixin.js" |
<<<<<<<
//-----------------------------------
// example3
import { ChronoIterator, ChronoGraph } from "../src/chrono/Graph.js"
=======
const identifier2 = Identifier.new({ calculation : (Y : SyncEffectHandler) => Y(identifier1) + 5 })
>>>>>>>
const identifier2 = Identifier.new({ calculation : (Y : SyncEffectHandler) => Y(identifier1) + 5 })
//-----------------------------------
// example3 |
<<<<<<<
import { copySetInto } from "../util/Helpers.js"
=======
import { clearLazyProperty, copySetInto, isGeneratorFunction, lazyProperty } from "../util/Helpers.js"
>>>>>>>
import { clearLazyProperty, copySetInto, isGeneratorFunction, lazyProperty } from "../util/Helpers.js"
<<<<<<<
this.$followingRevision = undefined
=======
clearLazyProperty(this, 'followingRevision')
this.markAndSweep()
>>>>>>>
this.$followingRevision = undefined
this.markAndSweep() |
<<<<<<<
import { Checkout } from "../chrono/Checkout.js"
import { CalculatedValueGen, Identifier } from "../chrono/Identifier.js"
import { AnyConstructor, Mixin } from "../class/BetterMixin.js"
=======
import { CheckoutI } from "../chrono/Checkout.js"
import { CalculatedValueGen, CalculatedValueSync, Identifier, Variable } from "../chrono/Identifier.js"
import { instanceOf } from "../class/InstanceOf.js"
import { AnyConstructor, Mixin, MixinConstructor } from "../class/Mixin.js"
>>>>>>>
import { Checkout } from "../chrono/Checkout.js"
import { CalculatedValueGen, CalculatedValueSync, Identifier, Variable } from "../chrono/Identifier.js"
import { AnyConstructor, Mixin } from "../class/BetterMixin.js"
<<<<<<<
export class MinimalFieldIdentifier extends FieldIdentifier.mix(CalculatedValueGen) {}
=======
export type FieldIdentifierConstructor = MixinConstructor<typeof FieldIdentifier>
export interface FieldIdentifierI extends FieldIdentifier {}
export class MinimalFieldIdentifierSync extends FieldIdentifier(CalculatedValueSync) {}
export class MinimalFieldIdentifierGen extends FieldIdentifier(CalculatedValueGen) {}
export class MinimalFieldVariable extends FieldIdentifier(Variable) {}
>>>>>>>
export class MinimalFieldIdentifierSync extends FieldIdentifier(CalculatedValueSync) {}
export class MinimalFieldIdentifierGen extends FieldIdentifier.mix(CalculatedValueGen) {}
export class MinimalFieldVariable extends FieldIdentifier(Variable) {} |
<<<<<<<
return this._activeTransaction = Transaction.new({
=======
return this.$activeTransaction = MinimalTransaction.new({
>>>>>>>
return this.$activeTransaction = Transaction.new({ |
<<<<<<<
import { Base } from "../class/BetterMixin.js"
import { NOT_VISITED, OnCycleAction, VISITED_TOPOLOGICALLY, WalkSource } from "../graph/WalkDepth.js"
=======
import { Base } from "../class/Mixin.js"
import { NOT_VISITED, OnCycleAction, VISITED_TOPOLOGICALLY } from "../graph/WalkDepth.js"
>>>>>>>
import { Base } from "../class/BetterMixin.js"
import { NOT_VISITED, OnCycleAction, VISITED_TOPOLOGICALLY } from "../graph/WalkDepth.js" |
<<<<<<<
describe('given only enforced content type', () => {
test('and that content type exists should first 200 static example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
mediaType: 'text/plain',
},
},
});
expect(response).toMatchSnapshot();
});
test('and that content type does not exist should throw', () => {
const rejection = mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
mediaType: 'text/funky',
},
},
});
return expect(rejection).rejects.toEqual(
new Error('Requested content type is not defined in the schema')
);
});
});
=======
describe('given enforced status code and contentType and exampleKey', () => {
test('should return the matching example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
exampleKey: 'second',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced status code and contentType', () => {
test('should return the first matching example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced example key', () => {
test('should return application/json, 200 response', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
exampleKey: 'bear',
},
},
});
expect(response).toMatchSnapshot();
});
test('and mediaType should return 200 response', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
exampleKey: 'second',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced status code', () => {
test('should return the first matching example of application/json', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
},
},
});
expect(response).toMatchSnapshot();
});
test('given that status code is not defined should throw an error', () => {
const rejection = mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '205',
},
},
});
return expect(rejection).rejects.toEqual(
new Error('Requested status code is not defined in the schema.')
);
});
test('and example key should return application/json example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
exampleKey: 'second',
},
},
});
expect(response).toMatchSnapshot();
});
});
>>>>>>>
describe('given only enforced content type', () => {
test('and that content type exists should first 200 static example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
mediaType: 'text/plain',
},
},
});
expect(response).toMatchSnapshot();
});
test('and that content type does not exist should throw', () => {
const rejection = mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
mediaType: 'text/funky',
},
},
});
return expect(rejection).rejects.toEqual(
new Error('Requested content type is not defined in the schema')
);
});
});
describe('given enforced status code and contentType and exampleKey', () => {
test('should return the matching example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
exampleKey: 'second',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced status code and contentType', () => {
test('should return the first matching example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced example key', () => {
test('should return application/json, 200 response', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
exampleKey: 'bear',
},
},
});
expect(response).toMatchSnapshot();
});
test('and mediaType should return 200 response', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
exampleKey: 'second',
mediaType: 'application/xml',
},
},
});
expect(response).toMatchSnapshot();
});
});
describe('given enforced status code', () => {
test('should return the first matching example of application/json', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
},
},
});
expect(response).toMatchSnapshot();
});
test('given that status code is not defined should throw an error', () => {
const rejection = mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '205',
},
},
});
return expect(rejection).rejects.toEqual(
new Error('Requested status code is not defined in the schema.')
);
});
test('and example key should return application/json example', async () => {
const response = await mocker.mock({
resource: httpOperations[0],
input: httpRequests[0],
config: {
mock: {
code: '201',
exampleKey: 'second',
},
},
});
expect(response).toMatchSnapshot();
});
}); |
<<<<<<<
import { configMergerFactory, IFilesystemLoaderOpts } from '@stoplight/prism-core';
import { createInstance, IHttpMethod, TPrismHttpInstance } from '@stoplight/prism-http';
=======
import { createInstance, IHttpMethod } from '@stoplight/prism-http';
import { TPrismHttpInstance } from '@stoplight/prism-http/types';
>>>>>>>
import { configMergerFactory } from '@stoplight/prism-core';
import { createInstance, IHttpMethod, TPrismHttpInstance } from '@stoplight/prism-http';
<<<<<<<
...components,
config,
})(loaderInput);
=======
config: getHttpConfigFromRequest,
...components,
});
>>>>>>>
...components,
config,
});
<<<<<<<
listen: server.listen.bind(server),
=======
listen: async (...args) => {
try {
await prism.load(loaderInput);
} catch (e) {
console.error('Error loading data into prism.', e);
throw e;
}
return server.listen(...args);
},
>>>>>>>
listen: async (port: number, ...args: any[]) => {
try {
await prism.load(loaderInput);
} catch (e) {
console.error('Error loading data into prism.', e);
throw e;
}
return server.listen(port, ...args);
}, |
<<<<<<<
import { IPrismInput, ValidationSeverity } from '@stoplight/prism-core/types';
import { IHttpMethod, IHttpRequest, IHttpResponse } from '@stoplight/prism-http/types';
=======
import { IPrismInput, ValidationSeverity } from '@stoplight/prism-core';
import { IHttpMethod, IHttpRequest } from '@stoplight/prism-http';
>>>>>>>
import { IPrismInput, ValidationSeverity } from '@stoplight/prism-core';
import { IHttpMethod, IHttpRequest, IHttpResponse } from '@stoplight/prism-http';
<<<<<<<
headers: [
{
name: 'x-todos-publish',
content: {
'*': {
mediaType: '*',
schema: { type: 'string', format: 'date-time' },
},
},
},
],
content: [
=======
contents: [
>>>>>>>
headers: [
{
name: 'x-todos-publish',
content: {
'*': {
mediaType: '*',
schema: { type: 'string', format: 'date-time' },
},
},
},
],
contents: [ |
<<<<<<<
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveClass("hydrated");
=======
const icon = await page.find("calcite-link >>> .calcite-link--icon");
expect(element).toHaveAttribute("calcite-hydrated");
>>>>>>>
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveAttribute("calcite-hydrated");
<<<<<<<
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveClass("hydrated");
=======
const icon = await page.find("calcite-link >>> .calcite-link--icon");
expect(element).toHaveAttribute("calcite-hydrated");
>>>>>>>
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveAttribute("calcite-hydrated");
<<<<<<<
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveClass("hydrated");
=======
const icon = await page.find("calcite-link >>> .calcite-link--icon");
expect(element).toHaveAttribute("calcite-hydrated");
>>>>>>>
const iconStart = await page.find(
"calcite-link >>> .calcite-link--icon.icon-start"
);
const iconEnd = await page.find(
"calcite-link >>> .calcite-link--icon.icon-end"
);
expect(element).toHaveAttribute("calcite-hydrated"); |
<<<<<<<
{ components: ["calcite-tree", "calcite-tree-item"] },
{ components: ["calcite-card"] },
{ components: ["calcite-icon"] }
=======
{ components: ["calcite-tooltip"] },
{ components: ["calcite-tree", "calcite-tree-item"] }
>>>>>>>
{ components: ["calcite-tooltip"] },
{ components: ["calcite-tree", "calcite-tree-item"] },
{ components: ["calcite-card"] },
{ components: ["calcite-icon"] } |
<<<<<<<
`<style>.hydrated--invisible {visibility: hidden;}</style><calcite-popover placement="auto" reference-element="ref">content</calcite-popover><calcite-popover-manager><div id="ref">referenceElement</div></calcite-popover-manager>`
=======
`<calcite-popover placement="auto" reference-element="ref" add-click-handle>content</calcite-popover><div id="ref">referenceElement</div>`
>>>>>>>
`<calcite-popover placement="auto" reference-element="ref">content</calcite-popover><calcite-popover-manager><div id="ref">referenceElement</div></calcite-popover-manager>` |
<<<<<<<
import { registerHiringTypes } from './hiring';
import { Codec } from '@polkadot/types/types';
=======
import { registerVersionedStoreTypes } from './versioned-store';
import { registerVersionedStorePermissionsTypes } from './versioned-store/permissions';
>>>>>>>
import { registerHiringTypes } from './hiring';
import { registerVersionedStoreTypes } from './versioned-store';
import { registerVersionedStorePermissionsTypes } from './versioned-store/permissions';
<<<<<<<
registerHiringTypes();
=======
registerVersionedStoreTypes();
registerVersionedStorePermissionsTypes();
>>>>>>>
registerHiringTypes();
registerVersionedStoreTypes();
registerVersionedStorePermissionsTypes(); |
<<<<<<<
const opening = new WorkingGroupOpening()
opening.setMaxActiveApplicants(new BN(m1KeyPairs.length))
opening.setMaxReviewPeriodLength(new BN(32))
opening.setApplicationStakingPolicyAmount(new BN(applicationStake))
opening.setApplicationCrowdedOutUnstakingPeriodLength(new BN(1))
opening.setApplicationExpiredUnstakingPeriodLength(new BN(1))
opening.setRoleStakingPolicyAmount(new BN(roleStake))
opening.setRoleCrowdedOutUnstakingPeriodLength(new BN(1))
opening.setRoleExpiredUnstakingPeriodLength(new BN(1))
opening.setSlashableMaxCount(new BN(1))
opening.setSlashableMaxPercentPtsPerTime(new BN(100))
opening.setSuccessfulApplicantApplicationStakeUnstakingPeriod(new BN(1))
opening.setFailedApplicantApplicationStakeUnstakingPeriod(new BN(1))
opening.setFailedApplicantRoleStakeUnstakingPeriod(new BN(1))
opening.setTerminateApplicationStakeUnstakingPeriod(new BN(1))
opening.setTerminateRoleStakeUnstakingPeriod(new BN(1))
opening.setExitRoleApplicationStakeUnstakingPeriod(new BN(1))
opening.setExitRoleStakeUnstakingPeriod(new BN(1))
opening.setText(uuid().substring(0, 8))
=======
const opening = new WorkingGroupOpening()
.setMaxActiveApplicants(new BN(m1KeyPairs.length))
.setMaxReviewPeriodLength(new BN(32))
.setApplicationStakingPolicyAmount(new BN(applicationStake))
.setApplicationCrowdedOutUnstakingPeriodLength(new BN(1))
.setApplicationExpiredUnstakingPeriodLength(new BN(1))
.setRoleStakingPolicyAmount(new BN(roleStake))
.setRoleCrowdedOutUnstakingPeriodLength(new BN(1))
.setRoleExpiredUnstakingPeriodLength(new BN(1))
.setSlashableMaxCount(new BN(1))
.setSlashableMaxPercentPtsPerTime(new BN(100))
.setSuccessfulApplicantApplicationStakeUnstakingPeriod(new BN(1))
.setFailedApplicantApplicationStakeUnstakingPeriod(new BN(1))
.setFailedApplicantRoleStakeUnstakingPeriod(new BN(1))
.setTerminateApplicationStakeUnstakingPeriod(new BN(1))
.setTerminateRoleStakeUnstakingPeriod(new BN(1))
.setExitRoleApplicationStakeUnstakingPeriod(new BN(1))
.setExitRoleStakeUnstakingPeriod(new BN(1))
.setText(uuid().substring(0, 8));
>>>>>>>
const opening = new WorkingGroupOpening()
.setMaxActiveApplicants(new BN(m1KeyPairs.length))
.setMaxReviewPeriodLength(new BN(32))
.setApplicationStakingPolicyAmount(new BN(applicationStake))
.setApplicationCrowdedOutUnstakingPeriodLength(new BN(1))
.setApplicationExpiredUnstakingPeriodLength(new BN(1))
.setRoleStakingPolicyAmount(new BN(roleStake))
.setRoleCrowdedOutUnstakingPeriodLength(new BN(1))
.setRoleExpiredUnstakingPeriodLength(new BN(1))
.setSlashableMaxCount(new BN(1))
.setSlashableMaxPercentPtsPerTime(new BN(100))
.setSuccessfulApplicantApplicationStakeUnstakingPeriod(new BN(1))
.setFailedApplicantApplicationStakeUnstakingPeriod(new BN(1))
.setFailedApplicantRoleStakeUnstakingPeriod(new BN(1))
.setTerminateApplicationStakeUnstakingPeriod(new BN(1))
.setTerminateRoleStakeUnstakingPeriod(new BN(1))
.setExitRoleApplicationStakeUnstakingPeriod(new BN(1))
.setExitRoleStakeUnstakingPeriod(new BN(1))
.setText(uuid().substring(0, 8))
<<<<<<<
)[0]
const now = await apiWrapper.getBestBlock()
const fillOpeningParameters: FillOpeningParameters = new FillOpeningParameters()
fillOpeningParameters.setAmountPerPayout(payoutAmount)
fillOpeningParameters.setNextPaymentAtBlock(now.add(firstRewardInterval))
fillOpeningParameters.setPayoutInterval(rewardInterval)
fillOpeningParameters.setOpeningId(openingId)
fillOpeningParameters.setSuccessfulApplicationId(applicationId)
fillOpeningParameters.setWorkingGroup(workingGroupString)
=======
)[0];
const now = await apiWrapper.getBestBlock();
const fillOpeningParameters: FillOpeningParameters = new FillOpeningParameters()
.setAmountPerPayout(payoutAmount)
.setNextPaymentAtBlock(now.add(firstRewardInterval))
.setPayoutInterval(rewardInterval)
.setOpeningId(openingId)
.setSuccessfulApplicationId(applicationId)
.setWorkingGroup(workingGroupString);
>>>>>>>
)[0]
const now = await apiWrapper.getBestBlock()
const fillOpeningParameters: FillOpeningParameters = new FillOpeningParameters()
.setAmountPerPayout(payoutAmount)
.setNextPaymentAtBlock(now.add(firstRewardInterval))
.setPayoutInterval(rewardInterval)
.setOpeningId(openingId)
.setSuccessfulApplicationId(applicationId)
.setWorkingGroup(workingGroupString) |
<<<<<<<
=======
SavedEntityEvent,
makeDatabaseManager,
SubstrateEvent,
>>>>>>> |
<<<<<<<
defaultWorkingGroup: WorkingGroups
=======
metadataCache: Record<string, any>
>>>>>>>
defaultWorkingGroup: WorkingGroups
metadataCache: Record<string, any>
<<<<<<<
defaultWorkingGroup: WorkingGroups.StorageProviders,
=======
metadataCache: {},
>>>>>>>
defaultWorkingGroup: WorkingGroups.StorageProviders,
metadataCache: {}, |
<<<<<<<
private static connectDataSource(sourceDS: IDataSource) {
// Connect sources and dependencies
sourceDS.store.listen((state) => {
Object.keys(this.dataSources).forEach(checkDSId => {
var checkDS = this.dataSources[checkDSId];
var dependencies = checkDS.plugin.getDependencies() || {};
let connected = _.find(_.keys(dependencies), dependencyKey => {
let dependencyValue = dependencies[dependencyKey] || '';
return (dependencyValue === sourceDS.id || dependencyValue.startsWith(sourceDS.id + ':'));
})
if (connected) {
// Todo: add check that all dependencies are met
checkDS.action.updateDependencies.defer(state);
}
});
// Checking visibility flags
let visibilityState = VisibilityStore.getState() || {};
let flags = visibilityState.flags || {};
let updatedFlags = {};
let shouldUpdate = false;
Object.keys(flags).forEach(visibilityKey => {
let keyParts = visibilityKey.split(':');
if (keyParts[0] === sourceDS.id) {
updatedFlags[visibilityKey] = sourceDS.store.getState()[keyParts[1]];
shouldUpdate = true;
}
});
if (shouldUpdate) {
(<any>VisibilityActions.setFlags).defer(updatedFlags);
}
});
}
=======
>>>>>>>
private static connectDataSource(sourceDS: IDataSource) {
// Connect sources and dependencies
sourceDS.store.listen((state) => {
Object.keys(this.dataSources).forEach(checkDSId => {
var checkDS = this.dataSources[checkDSId];
var dependencies = checkDS.plugin.getDependencies() || {};
let connected = _.find(_.keys(dependencies), dependencyKey => {
let dependencyValue = dependencies[dependencyKey] || '';
return (dependencyValue === sourceDS.id || dependencyValue.startsWith(sourceDS.id + ':'));
})
if (connected) {
// Todo: add check that all dependencies are met
checkDS.action.updateDependencies.defer(state);
}
});
// Checking visibility flags
let visibilityState = VisibilityStore.getState() || {};
let flags = visibilityState.flags || {};
let updatedFlags = {};
let shouldUpdate = false;
Object.keys(flags).forEach(visibilityKey => {
let keyParts = visibilityKey.split(':');
if (keyParts[0] === sourceDS.id) {
updatedFlags[visibilityKey] = sourceDS.store.getState()[keyParts[1]];
shouldUpdate = true;
}
});
if (shouldUpdate) {
(<any>VisibilityActions.setFlags).defer(updatedFlags);
}
});
}
<<<<<<<
// Checking to see if any of the dependencies control visibility
let visibilityFlags = {};
let updateVisibility = false;
Object.keys(result.dependencies).forEach(key => {
if (key === 'visible') {
visibilityFlags[dependencies[key]] = result.dependencies[key];
updateVisibility = true;
}
});
if (updateVisibility) {
(<any>VisibilityActions.setFlags).defer(visibilityFlags);
}
=======
>>>>>>>
// Checking to see if any of the dependencies control visibility
let visibilityFlags = {};
let updateVisibility = false;
Object.keys(result.dependencies).forEach(key => {
if (key === 'visible') {
visibilityFlags[dependencies[key]] = result.dependencies[key];
updateVisibility = true;
}
});
if (updateVisibility) {
(<any>VisibilityActions.setFlags).defer(visibilityFlags);
} |
<<<<<<<
async getBlockHash(blockNumber?: BlockNumber | Uint8Array | number | string) {
debug(`Fetching block hash: BlockNumber: ${blockNumber}`)
=======
getBlockHash(blockNumber?: BlockNumber | Uint8Array | number | string): Promise<Hash> {
>>>>>>>
async getBlockHash(blockNumber?: BlockNumber | Uint8Array | number | string): Promise<Hash> {
debug(`Fetching block hash: BlockNumber: ${blockNumber}`)
<<<<<<<
async getBlock(hash: Hash | Uint8Array | string) {
debug(`Fething block: BlockHash: ${hash}`)
=======
async getBlock(hash: Hash | Uint8Array | string): Promise<SignedBlock> {
>>>>>>>
async getBlock(hash: Hash | Uint8Array | string): Promise<SignedBlock> {
debug(`Fething block: BlockHash: ${hash}`)
<<<<<<<
async eventsAt(hash: Hash | Uint8Array | string) {
debug(`Fething events. BlockHash: ${hash}`)
=======
async eventsAt(hash: Hash | Uint8Array | string): Promise<EventRecord[] & Codec> {
>>>>>>>
async eventsAt(hash: Hash | Uint8Array | string): Promise<EventRecord[] & Codec> {
debug(`Fething events. BlockHash: ${hash}`) |
<<<<<<<
WorkerApplication, WorkerApplicationId, WorkerOpening, WorkerOpeningId
} from '@joystream/types/working-group';
=======
WorkerApplication, WorkerApplicationId,
WorkerOpening, WorkerOpeningId,
Worker, WorkerId,
WorkerRoleStakeProfile,
Lead as LeadOf
} from '@joystream/types/bureaucracy';
>>>>>>>
WorkerApplication, WorkerApplicationId,
WorkerOpening, WorkerOpeningId,
Worker, WorkerId,
WorkerRoleStakeProfile,
Lead as LeadOf
} from '@joystream/types/working-group'; |
<<<<<<<
import { DataSourceConnector } from '../../DataSourceConnector';
import * as formats from '../../../utils/data-formats';
=======
import { DataSourceConnector, IDataSource } from '../../DataSourceConnector';
>>>>>>>
import { DataSourceConnector, IDataSource } from '../../DataSourceConnector';
import * as formats from '../../../utils/data-formats'; |
<<<<<<<
type FormattedCategory = {
handle: string;
id: string;
title: string;
items: { id: string; title: string }[];
}[];
function formatCategories(rootCategory: CommerceTypes.Category): FormattedCategory {
return (rootCategory.categories || []).map(subCategory => ({
=======
export function formatCategories(rootCategory: CommerceTypes.Category): any {
return (rootCategory.categories || []).map((subCategory: CommerceTypes.Category) => ({
>>>>>>>
type FormattedCategory = {
handle: string;
id: string;
title: string;
items: { id: string; title: string }[];
}[];
export function formatCategories(rootCategory: CommerceTypes.Category): FormattedCategory {
return (rootCategory.categories || []).map(subCategory => ({ |
<<<<<<<
// attach write method
this._writeMethod = (data: string) => this._defer(() => this._agent.inSocket.write(data));
=======
this._forwardEvents();
>>>>>>>
this._forwardEvents();
// attach write method
this._writeMethod = (data: string) => this._defer(() => this._agent.inSocket.write(data)); |
<<<<<<<
/**
* Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
* will pause the socket and thus blocking the slave program execution due to buffer back pressure.
* A message of `flowControlResume` will resume the socket into flow mode.
* For performance reasons only a single message as a whole will match (no message part matching).
* If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
* the underlying pseudoterminal.
*/
handleFlowControl?: boolean;
/**
* The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
*/
flowControlPause?: string;
/**
* The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
*/
flowControlResume?: string;
=======
/**
* Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
* @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
*/
conptyInheritCursor?: boolean;
>>>>>>>
/**
* Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
* @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
*/
conptyInheritCursor?: boolean;
/**
* Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
* will pause the socket and thus blocking the slave program execution due to buffer back pressure.
* A message of `flowControlResume` will resume the socket into flow mode.
* For performance reasons only a single message as a whole will match (no message part matching).
* If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
* the underlying pseudoterminal.
*/
handleFlowControl?: boolean;
/**
* The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
*/
flowControlPause?: string;
/**
* The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
*/
flowControlResume?: string; |
<<<<<<<
const args = definition.constructorArgs.map(val => (val as ManagedReference).name);
if (args.indexOf(identifier) > -1) {
return true;
}
const keys = definition.properties.keys();
if (keys.indexOf(identifier) > -1) {
return true;
}
for (const key of keys) {
let subDefinition = this.context.registry.getDefinition(key);
if (!subDefinition && this.context.parent) {
subDefinition = this.context.parent.registry.getDefinition(key);
}
if (this.depthFirstSearch(identifier, subDefinition)) {
return true;
=======
if (definition) {
if (definition.constructorArgs) {
const args = definition.constructorArgs.map(val => (val as ManagedReference).name);
if (args.indexOf(identifier) > -1) {
return true;
}
}
if (definition.properties) {
const keys = definition.properties.keys();
if (keys.indexOf(identifier) > -1) {
return true;
}
for (const key of keys) {
const subDefinition = this.context.registry.getDefinition(key);
if (this.depthFirstSearch(identifier, subDefinition)) {
return true;
}
}
>>>>>>>
if (definition) {
if (definition.constructorArgs) {
const args = definition.constructorArgs.map(val => (val as ManagedReference).name);
if (args.indexOf(identifier) > -1) {
return true;
}
}
if (definition.properties) {
const keys = definition.properties.keys();
if (keys.indexOf(identifier) > -1) {
return true;
}
for (const key of keys) {
let subDefinition = this.context.registry.getDefinition(key);
if (!subDefinition && this.context.parent) {
subDefinition = this.context.parent.registry.getDefinition(key);
}
if (this.depthFirstSearch(identifier, subDefinition)) {
return true;
}
} |
<<<<<<<
import { MatProgressButtonsModule } from 'mat-progress-buttons';
=======
import { MatModule } from './mat-module';
>>>>>>>
import { MatModule } from './mat-module';
import { MatProgressButtonsModule } from 'mat-progress-buttons';
<<<<<<<
MatProgressButtonsModule.forRoot(),
=======
MatModule,
>>>>>>>
MatProgressButtonsModule.forRoot(),
MatModule, |
<<<<<<<
this.dataSource.filterPredicate = this.filterListItem;
=======
this.dataSource.filterPredicate = (
item: AddonViewModel,
filter: string
) => {
if (
stringIncludes(item.addon.name, filter) ||
stringIncludes(item.addon.latestVersion, filter) ||
stringIncludes(item.addon.author, filter)
) {
return true;
}
return false;
};
>>>>>>>
this.dataSource.filterPredicate = this.filterListItem;
<<<<<<<
onRowClicked(event: MouseEvent, row: MyAddonsListItem, index: number) {
console.log("index clicked: " + index, row.addon.name);
=======
onRowClicked(event: MouseEvent, row: AddonViewModel, index: number) {
console.log(row.displayState);
console.log("index clicked: " + index);
>>>>>>>
onRowClicked(event: MouseEvent, row: AddonViewModel, index: number) {
console.log(row.displayState);
console.log("index clicked: " + index);
<<<<<<<
=======
let listItems: AddonViewModel[] = [].concat(this._displayAddonsSrc.value);
>>>>>>>
<<<<<<<
onClickIgnoreAddon(evt: MatCheckboxChange, listItem: MyAddonsListItem) {
this.onClickIgnoreAddons(evt, [listItem]);
}
onClickIgnoreAddons(evt: MatCheckboxChange, listItems: MyAddonsListItem[]) {
listItems.forEach((listItem) => {
listItem.addon.isIgnored = evt.checked;
if (evt.checked) {
listItem.addon.autoUpdateEnabled = false;
}
listItem.statusText = listItem.getStateText();
this.addonService.saveAddon(listItem.addon);
});
if (!this.sort.active) {
this.sortTable(this.dataSource);
}
}
onClickAutoUpdateAddon(evt: MatCheckboxChange, listItem: MyAddonsListItem) {
this.onClickAutoUpdateAddons(evt, [listItem]);
}
onClickAutoUpdateAddons(
evt: MatCheckboxChange,
listItems: MyAddonsListItem[]
) {
listItems.forEach((listItem) => {
listItem.addon.autoUpdateEnabled = evt.checked;
if (evt.checked) {
listItem.addon.isIgnored = false;
}
this.addonService.saveAddon(listItem.addon);
});
if (!this.sort.active) {
this.sortTable(this.dataSource);
}
=======
onClickIgnoreAddon(evt: MatCheckboxChange, listItem: AddonViewModel) {
listItem.addon.isIgnored = evt.checked;
listItem.statusText = listItem.getStateText();
this.addonService.saveAddon(listItem.addon);
>>>>>>>
onClickIgnoreAddon(evt: MatCheckboxChange, listItem: AddonViewModel) {
this.onClickIgnoreAddons(evt, [listItem]);
}
onClickIgnoreAddons(evt: MatCheckboxChange, listItems: AddonViewModel[]) {
listItems.forEach((listItem) => {
listItem.addon.isIgnored = evt.checked;
if (evt.checked) {
listItem.addon.autoUpdateEnabled = false;
}
listItem.statusText = listItem.getStateText();
this.addonService.saveAddon(listItem.addon);
});
if (!this.sort.active) {
this.sortTable(this.dataSource);
}
}
onClickAutoUpdateAddon(evt: MatCheckboxChange, listItem: AddonViewModel) {
this.onClickAutoUpdateAddons(evt, [listItem]);
}
onClickAutoUpdateAddons(
evt: MatCheckboxChange,
listItems: AddonViewModel[]
) {
listItems.forEach((listItem) => {
listItem.addon.autoUpdateEnabled = evt.checked;
if (evt.checked) {
listItem.addon.isIgnored = false;
}
this.addonService.saveAddon(listItem.addon);
});
if (!this.sort.active) {
this.sortTable(this.dataSource);
}
<<<<<<<
private sortListItems(listItems: MyAddonsListItem[], sort?: MatSort) {
if (!sort || !sort.active || sort.direction === "") {
return _.orderBy(listItems, ["displayState", "addon.name"]);
}
return _.orderBy(
listItems,
[(listItem) => _.get(listItem, sort.active, "")],
[sort.direction === "asc" ? "asc" : "desc"]
);
}
private filterListItem(item: MyAddonsListItem, filter: string) {
if (
stringIncludes(item.addon.name, filter) ||
stringIncludes(item.addon.latestVersion, filter) ||
stringIncludes(item.addon.author, filter)
) {
return true;
}
return false;
=======
private sortListItems(listItems: AddonViewModel[]) {
return _.orderBy(listItems, ["displayState", "addon.name"]);
>>>>>>>
private sortListItems(listItems: AddonViewModel[], sort?: MatSort) {
if (!sort || !sort.active || sort.direction === "") {
return _.orderBy(listItems, ["displayState", "addon.name"]);
}
return _.orderBy(
listItems,
[(listItem) => _.get(listItem, sort.active, "")],
[sort.direction === "asc" ? "asc" : "desc"]
);
}
private filterListItem(item: AddonViewModel, filter: string) {
if (
stringIncludes(item.addon.name, filter) ||
stringIncludes(item.addon.latestVersion, filter) ||
stringIncludes(item.addon.author, filter)
) {
return true;
}
return false; |
<<<<<<<
import { app, BrowserWindow, screen, BrowserWindowConstructorOptions, Tray, Menu, nativeImage, ipcMain, MenuItem, MenuItemConstructorOptions } from 'electron';
import * as path from 'path';
import * as url from 'url';
import * as fs from 'fs';
import { release, arch } from 'os';
import * as electronDl from 'electron-dl';
import * as admZip from 'adm-zip';
import { DownloadRequest } from './src/common/models/download-request';
import { DownloadStatus } from './src/common/models/download-status';
import { DownloadStatusType } from './src/common/models/download-status-type';
import { UnzipStatus } from './src/common/models/unzip-status';
import { DOWNLOAD_FILE_CHANNEL, UNZIP_FILE_CHANNEL, COPY_FILE_CHANNEL, COPY_DIRECTORY_CHANNEL, DELETE_DIRECTORY_CHANNEL, RENAME_DIRECTORY_CHANNEL, READ_FILE_CHANNEL } from './src/common/constants';
import { UnzipStatusType } from './src/common/models/unzip-status-type';
import { UnzipRequest } from './src/common/models/unzip-request';
import { CopyFileRequest } from './src/common/models/copy-file-request';
import { CopyDirectoryRequest } from './src/common/models/copy-directory-request';
import { DeleteDirectoryRequest } from './src/common/models/delete-directory-request';
import { ReadFileRequest } from './src/common/models/read-file-request';
import { ReadFileResponse } from './src/common/models/read-file-response';
import './ipc-events';
import { ncp } from 'ncp';
import * as rimraf from 'rimraf';
import * as log from 'electron-log';
import { autoUpdater } from "electron-updater"
import * as Store from 'electron-store'
import { WindowState } from './src/app/models/wowup/window-state';
import { isBetween } from './src/app/utils/number.utils';
import { Subject } from 'rxjs';
import { debounceTime } from 'rxjs/operators';
const isMac = process.platform === 'darwin';
const isWin = process.platform === 'win32';
const preferenceStore = new Store({ name: 'preferences' });
=======
import {
app,
BrowserWindow,
screen,
BrowserWindowConstructorOptions,
Tray,
Menu,
nativeImage,
ipcMain,
MenuItem,
MenuItemConstructorOptions,
} from "electron";
import * as path from "path";
import * as url from "url";
import * as fs from "fs";
import { release, arch } from "os";
import * as electronDl from "electron-dl";
import * as admZip from "adm-zip";
import { DownloadRequest } from "./src/common/models/download-request";
import { DownloadStatus } from "./src/common/models/download-status";
import { DownloadStatusType } from "./src/common/models/download-status-type";
import { UnzipStatus } from "./src/common/models/unzip-status";
import {
DOWNLOAD_FILE_CHANNEL,
UNZIP_FILE_CHANNEL,
COPY_FILE_CHANNEL,
COPY_DIRECTORY_CHANNEL,
DELETE_DIRECTORY_CHANNEL,
RENAME_DIRECTORY_CHANNEL,
READ_FILE_CHANNEL,
} from "./src/common/constants";
import { UnzipStatusType } from "./src/common/models/unzip-status-type";
import { UnzipRequest } from "./src/common/models/unzip-request";
import { CopyFileRequest } from "./src/common/models/copy-file-request";
import { CopyDirectoryRequest } from "./src/common/models/copy-directory-request";
import { DeleteDirectoryRequest } from "./src/common/models/delete-directory-request";
import { ReadFileRequest } from "./src/common/models/read-file-request";
import { ReadFileResponse } from "./src/common/models/read-file-response";
import "./ipc-events";
import { ncp } from "ncp";
import * as rimraf from "rimraf";
import * as log from "electron-log";
import { autoUpdater } from "electron-updater";
import * as Store from "electron-store";
import { readFile } from "./file.utils";
const isMac = process.platform === "darwin";
const isWin = process.platform === "win32";
const preferenceStore = new Store({ name: "preferences" });
>>>>>>>
import {
app,
BrowserWindow,
screen,
BrowserWindowConstructorOptions,
Tray,
Menu,
nativeImage,
ipcMain,
MenuItem,
MenuItemConstructorOptions,
} from "electron";
import * as path from "path";
import * as url from "url";
import * as fs from "fs";
import { release, arch } from "os";
import * as electronDl from "electron-dl";
import * as admZip from "adm-zip";
import { DownloadRequest } from "./src/common/models/download-request";
import { DownloadStatus } from "./src/common/models/download-status";
import { DownloadStatusType } from "./src/common/models/download-status-type";
import { UnzipStatus } from "./src/common/models/unzip-status";
import {
DOWNLOAD_FILE_CHANNEL,
UNZIP_FILE_CHANNEL,
COPY_FILE_CHANNEL,
COPY_DIRECTORY_CHANNEL,
DELETE_DIRECTORY_CHANNEL,
RENAME_DIRECTORY_CHANNEL,
READ_FILE_CHANNEL,
} from "./src/common/constants";
import { UnzipStatusType } from "./src/common/models/unzip-status-type";
import { UnzipRequest } from "./src/common/models/unzip-request";
import { CopyFileRequest } from "./src/common/models/copy-file-request";
import { CopyDirectoryRequest } from "./src/common/models/copy-directory-request";
import { DeleteDirectoryRequest } from "./src/common/models/delete-directory-request";
import { ReadFileRequest } from "./src/common/models/read-file-request";
import { ReadFileResponse } from "./src/common/models/read-file-response";
import "./ipc-events";
import { ncp } from "ncp";
import * as rimraf from "rimraf";
import * as log from "electron-log";
import { autoUpdater } from "electron-updater";
import * as Store from "electron-store";
import { readFile } from "./file.utils";
import { WindowState } from './src/app/models/wowup/window-state';
import { isBetween } from './src/app/utils/number.utils';
import { Subject } from 'rxjs';
import { debounceTime } from 'rxjs/operators';
const isMac = process.platform === "darwin";
const isWin = process.platform === "win32";
const preferenceStore = new Store({ name: "preferences" });
<<<<<<<
function windowStateManager(windowName: string, { width, height }: { width: number, height: number }) {
let window: BrowserWindow;
let windowState: WindowState;
const saveState$ = new Subject<void>();
function setState() {
let setDefaults = false;
windowState = preferenceStore.get(`${windowName}-window-state`) as WindowState;
if (!windowState) {
setDefaults = true;
} else {
log.info('found window state:', windowState);
const displays = screen.getAllDisplays();
const maxDisplay = displays.reduce((prev, current) => prev.bounds.x > current.bounds.x ? prev : current);
const minDisplay = displays.reduce((prev, current) => prev.bounds.x < current.bounds.x ? prev : current);
log.info('min display:', minDisplay);
log.info('max display:', maxDisplay);
if (!isBetween(windowState.x, minDisplay.bounds.x, maxDisplay.bounds.width, true) ||
!isBetween(windowState.y, minDisplay.bounds.y, maxDisplay.bounds.height, true)) {
log.info('reset window state, bounds are outside displays');
setDefaults = true;
}
}
if (setDefaults) {
log.info('setting window defaults');
windowState = <WindowState>{ width, height };
}
}
function saveState() {
log.info('saving window state');
if (!window.isMaximized() && !window.isFullScreen()) {
windowState = { ...windowState, ...window.getBounds() };
}
windowState.isMaximized = window.isMaximized();
windowState.isFullScreen = window.isFullScreen();
preferenceStore.set(`${windowName}-window-state`, windowState);
}
function monitorState(win: BrowserWindow) {
window = win;
win.on('close', saveState);
win.on('resize', () => saveState$.next());
win.on('move', () => saveState$.next());
win.on('closed', () => saveState$.unsubscribe());
}
saveState$
.pipe(debounceTime(500))
.subscribe(() => saveState());
setState();
return({
...windowState,
monitorState,
});
}
function createWindow(): BrowserWindow {
// Main object for managing window state
// Initialize with a window name and default size
const mainWindowManager = windowStateManager('main', { width: 900, height: 600 });
=======
function createWindow(): BrowserWindow {
const electronScreen = screen;
const size = electronScreen.getPrimaryDisplay().workAreaSize;
>>>>>>>
function windowStateManager(windowName: string, { width, height }: { width: number, height: number }) {
let window: BrowserWindow;
let windowState: WindowState;
const saveState$ = new Subject<void>();
function setState() {
let setDefaults = false;
windowState = preferenceStore.get(`${windowName}-window-state`) as WindowState;
if (!windowState) {
setDefaults = true;
} else {
log.info('found window state:', windowState);
const displays = screen.getAllDisplays();
const maxDisplay = displays.reduce((prev, current) => prev.bounds.x > current.bounds.x ? prev : current);
const minDisplay = displays.reduce((prev, current) => prev.bounds.x < current.bounds.x ? prev : current);
log.info('min display:', minDisplay);
log.info('max display:', maxDisplay);
if (!isBetween(windowState.x, minDisplay.bounds.x, maxDisplay.bounds.width, true) ||
!isBetween(windowState.y, minDisplay.bounds.y, maxDisplay.bounds.height, true)) {
log.info('reset window state, bounds are outside displays');
setDefaults = true;
}
}
if (setDefaults) {
log.info('setting window defaults');
windowState = <WindowState>{ width, height };
}
}
function saveState() {
log.info('saving window state');
if (!window.isMaximized() && !window.isFullScreen()) {
windowState = { ...windowState, ...window.getBounds() };
}
windowState.isMaximized = window.isMaximized();
windowState.isFullScreen = window.isFullScreen();
preferenceStore.set(`${windowName}-window-state`, windowState);
}
function monitorState(win: BrowserWindow) {
window = win;
win.on('close', saveState);
win.on('resize', () => saveState$.next());
win.on('move', () => saveState$.next());
win.on('closed', () => saveState$.unsubscribe());
}
saveState$
.pipe(debounceTime(500))
.subscribe(() => saveState());
setState();
return ({
...windowState,
monitorState,
});
}
function createWindow(): BrowserWindow {
// Main object for managing window state
// Initialize with a window name and default size
const mainWindowManager = windowStateManager('main', { width: 900, height: 600 });
<<<<<<<
width: mainWindowManager.width,
height: mainWindowManager.height,
x: mainWindowManager.x,
y: mainWindowManager.y,
backgroundColor: '#444444',
title: 'WowUp',
titleBarStyle: 'hidden',
=======
width: 900,
height: 600,
backgroundColor: "#444444",
// frame: false,
title: "WowUp",
titleBarStyle: "hidden",
>>>>>>>
width: mainWindowManager.width,
height: mainWindowManager.height,
x: mainWindowManager.x,
y: mainWindowManager.y,
backgroundColor: '#444444',
title: 'WowUp',
titleBarStyle: 'hidden',
<<<<<<<
minHeight: 550,
show: false,
=======
minHeight: 550,
>>>>>>>
minHeight: 550,
show: false,
<<<<<<<
win.once('ready-to-show', () => {
win.show();
autoUpdater.checkForUpdatesAndNotify()
.then((result) => {
console.log('UPDATE', result)
})
=======
win.once("ready-to-show", () => {
autoUpdater.checkForUpdatesAndNotify().then((result) => {
console.log("UPDATE", result);
});
>>>>>>>
win.once('ready-to-show', () => {
win.show();
autoUpdater.checkForUpdatesAndNotify()
.then((result) => {
console.log('UPDATE', result)
}) |
<<<<<<<
import { WowUpService } from "app/services/wowup/wowup.service";
import { defaultChannelKeySuffix } from "../../../constants";
import { getEnumName } from "app/utils/enum.utils";
import { AddonChannelType } from "app/models/wowup/addon-channel-type";
=======
import { GetAddonListItem } from "app/business-objects/get-addon-list-item";
import { AddonSearchResult } from "app/models/wowup/addon-search-result";
>>>>>>>
import { GetAddonListItem } from "app/business-objects/get-addon-list-item";
import { AddonSearchResult } from "app/models/wowup/addon-search-result";
import { AddonChannelType } from "app/models/wowup/addon-channel-type";
import { WowUpService } from "app/services/wowup/wowup.service"; |
<<<<<<<
public title: string = 'TITLE.CLICKER_LIST';
=======
public title: string;
public version: string;
>>>>>>>
public title: string;
public version: string;
<<<<<<<
=======
this.title = 'Clickers';
this.version = version;
>>>>>>>
this.version = version; |
<<<<<<<
var startMinimized = (process.argv || []).indexOf('--hidden') !== -1;
if (!startMinimized)
win.show();
autoUpdater.checkForUpdatesAndNotify().then((result) => {
console.log("UPDATE", result);
});
=======
win.show();
>>>>>>>
var startMinimized = (process.argv || []).indexOf('--hidden') !== -1;
if (!startMinimized)
win.show(); |
<<<<<<<
var autoLaunch = require("auto-launch");
=======
const autoLaunch = require("auto-launch");
>>>>>>>
const autoLaunch = require("auto-launch");
<<<<<<<
private _fileService: FileService
=======
private _fileService: FileService,
>>>>>>>
private _fileService: FileService,
<<<<<<<
this._electronService.ipcEventReceived$.subscribe((evt) => {
switch (evt) {
case APP_UPDATE_CHECK_START:
console.log(APP_UPDATE_CHECK_START);
this._wowupUpdateCheckInProgressSrc.next(true);
break;
case APP_UPDATE_CHECK_END:
console.log(APP_UPDATE_CHECK_END);
this._wowupUpdateCheckInProgressSrc.next(false);
break;
case APP_UPDATE_START_DOWNLOAD:
console.log(APP_UPDATE_START_DOWNLOAD);
this._wowupUpdateDownloadInProgressSrc.next(true);
break;
case APP_UPDATE_DOWNLOADED:
console.log(APP_UPDATE_DOWNLOADED);
this._wowupUpdateDownloadInProgressSrc.next(false);
break;
}
});
=======
this.setAutoStartup();
console.log('loginItemSettings', this._electronService.loginItemSettings);
>>>>>>>
this._electronService.ipcEventReceived$.subscribe((evt) => {
switch (evt) {
case APP_UPDATE_CHECK_START:
console.log(APP_UPDATE_CHECK_START);
this._wowupUpdateCheckInProgressSrc.next(true);
break;
case APP_UPDATE_CHECK_END:
console.log(APP_UPDATE_CHECK_END);
this._wowupUpdateCheckInProgressSrc.next(false);
break;
case APP_UPDATE_START_DOWNLOAD:
console.log(APP_UPDATE_START_DOWNLOAD);
this._wowupUpdateDownloadInProgressSrc.next(true);
break;
case APP_UPDATE_DOWNLOADED:
console.log(APP_UPDATE_DOWNLOADED);
this._wowupUpdateDownloadInProgressSrc.next(false);
break;
}
});
this.setAutoStartup();
console.log('loginItemSettings', this._electronService.loginItemSettings); |
<<<<<<<
savedData[id].date = new Date(savedData[id].date).toString();
return savedData[id];
});
=======
const matchesList: InternalMatch[] = newMatchesIndex
.filter(
(id: string) =>
savedData[id] &&
savedData[id].gameStats?.length > 0 &&
savedData[id]?.gameStats[0] !== undefined
)
.map((id: string) => {
// Calculate player deck hash
if (savedData[id].playerDeck && !savedData[id].playerDeckHash) {
const playerDeck = new Deck(savedData[id].playerDeck);
savedData[id].playerDeckHash = playerDeck.getHash();
}
savedData[id].date = new Date(savedData[id].date ?? 0).toISOString();
return savedData[id];
});
>>>>>>>
savedData[id].date = new Date(savedData[id].date ?? 0).toISOString();
return savedData[id];
}); |
<<<<<<<
let nodeModule = path.join(vscode.workspace.rootPath, "node_modules", "flexjs");
if(validateFrameworkSDK(nodeModule))
=======
let flexjsModule = path.join(vscode.workspace.workspaceFolders[0].uri.fsPath, "node_modules", "flexjs");
if(validateFrameworkSDK(flexjsModule))
>>>>>>>
let nodeModule = path.join(vscode.workspace.workspaceFolders[0].uri.fsPath, "node_modules", "flexjs");
if(validateFrameworkSDK(nodeModule)) |
<<<<<<<
let browserViews: BrowserView[] = (global['browserViews'] = global['browserViews'] || []) as BrowserView[];
=======
const browserViews: Electron.BrowserView[] = [];
>>>>>>>
const browserViews: BrowserView[] = (global['browserViews'] = global['browserViews'] || []) as BrowserView[]; |
<<<<<<<
private getNodesPromise(folder: string, opts?: any) {
let alfrescoClient = this.getAlfrescoClient();
let apiInstance = new AlfrescoApi.Core.NodesApi(alfrescoClient);
=======
private getNodesPromise(folder: string) {
>>>>>>>
private getNodesPromise(folder: string, opts?: any) {
<<<<<<<
=======
return this.getAlfrescoApi().node.getNodeChildren(nodeId, opts);
}
>>>>>>> |
<<<<<<<
import { AlfrescoTranslateService } from 'ng2-alfresco-core';
import { ObjectDataTableAdapter, DataTableAdapter, DataRowEvent, ObjectDataRow } from 'ng2-alfresco-datatable';
import { TaskQueryRequestRepresentationModel } from 'ng2-activiti-tasklist';
=======
import { AlfrescoTranslationService } from 'ng2-alfresco-core';
import { ObjectDataTableAdapter, DataTableAdapter, DataRowEvent, ObjectDataRow, DataSorting } from 'ng2-alfresco-datatable';
import { ProcessFilterRequestRepresentation } from '../models/process-instance-filter.model';
>>>>>>>
import { AlfrescoTranslateService } from 'ng2-alfresco-core';
import { ObjectDataTableAdapter, DataTableAdapter, DataRowEvent, ObjectDataRow, DataSorting } from 'ng2-alfresco-datatable';
import { TaskQueryRequestRepresentationModel } from 'ng2-activiti-tasklist';
import { ProcessFilterRequestRepresentation } from '../models/process-instance-filter.model'; |
<<<<<<<
import { AlfrescoTranslateService, CoreModule } from 'ng2-alfresco-core';
import { DataTableModule, ObjectDataRow, DataRowEvent, ObjectDataTableAdapter } from 'ng2-alfresco-datatable';
=======
import { AlfrescoTranslationService, CoreModule } from 'ng2-alfresco-core';
import { DataTableModule, ObjectDataRow, DataRowEvent, ObjectDataTableAdapter, DataSorting } from 'ng2-alfresco-datatable';
>>>>>>>
import { AlfrescoTranslateService, CoreModule } from 'ng2-alfresco-core';
import { DataTableModule, ObjectDataRow, DataRowEvent, ObjectDataTableAdapter, DataSorting } from 'ng2-alfresco-datatable'; |
<<<<<<<
import { ActivitiDemoComponent } from './components/activiti/activiti-demo.component';
=======
import { WebscriptComponent } from './components/webscript/webscript.component';
>>>>>>>
import { ActivitiDemoComponent } from './components/activiti/activiti-demo.component';
import { WebscriptComponent } from './components/webscript/webscript.component';
<<<<<<<
{path: '/tasks', name: 'Tasks', component: TasksDemoComponent},
{path: '/activiti', name: 'Activiti', component: ActivitiDemoComponent}
=======
{path: '/tasks', name: 'Tasks', component: TasksDemoComponent},
{path: '/webscript', name: 'Webscript', component: WebscriptComponent}
>>>>>>>
{path: '/tasks', name: 'Tasks', component: TasksDemoComponent},
{path: '/activiti', name: 'Activiti', component: ActivitiDemoComponent},
{path: '/webscript', name: 'Webscript', component: WebscriptComponent} |
<<<<<<<
import { Schemas as Interfaces } from '../lib/interfaces'
=======
import { Schemas } from '../lib/interfaces'
import { logger } from '../lib/logger'
>>>>>>>
import { Schemas as Interfaces } from '../lib/interfaces'
import { logger } from '../lib/logger'
<<<<<<<
export async function list(
/** A Postgres connection string */
connection: string,
{
/** If true, will include the system schemas */
include_system_schemas = false,
}: {
include_system_schemas?: boolean
=======
interface QueryParams {
include_system_schemas?: string
}
const router = Router()
router.get('/', async (req, res) => {
try {
const { data } = await RunQuery(req.headers.pg, schemas)
const query: QueryParams = req.query
const include_system_schemas = query?.include_system_schemas === 'true'
let payload: Schemas.Schema[] = data
if (!include_system_schemas) payload = removeSystemSchemas(data)
return res.status(200).json(payload)
} catch (error) {
logger.error({ error, req: req.body })
res.status(500).json({ error: error.message })
>>>>>>>
export async function list(
/** A Postgres connection string */
connection: string,
{
/** If true, will include the system schemas */
include_system_schemas = false,
}: {
include_system_schemas?: boolean
<<<<<<<
return { data: null, error }
=======
logger.error({ error, req: req.body })
res.status(400).json({ error: error.message })
>>>>>>>
logger.error({ error })
return { data: null, error }
<<<<<<<
return { data: null, error }
=======
logger.error({ error, req: req.body })
res.status(400).json({ error: error.message })
>>>>>>>
logger.error({ error })
return { data: null, error } |
<<<<<<<
document.addEventListener('browserplugin.from.extension.fnd.opened', (event: CustomEvent) => {
Utils.openedByBrowserplugin = true;
});
=======
this.passGetParams();
>>>>>>>
this.passGetParams();
document.addEventListener('browserplugin.from.extension.fnd.opened', (event: CustomEvent) => {
Utils.openedByBrowserplugin = true;
}); |
<<<<<<<
import {TypedEventEmitter} from "TypedEventEmitter";
import {Batcher} from "batcher";
=======
import {Publisher, Subscriber as RealSubscriber} from "pubsub";
// The player cache's Subscriber is just like a vanilla Subscriber, but can
// subscribe to and unsubscribe from numerical ids or whole Players. The
// function to query which players we are watching is called "players", not
// "channels".
let publisher = new Publisher<{[id: string]: PlayerCacheEntry}>();
export class Subscriber {
private subscriber: RealSubscriber<{[id: string]: PlayerCacheEntry}, string>;
constructor(callback: (player: PlayerCacheEntry) => void) {
this.subscriber = new publisher.Subscriber((id, player) => callback(player));
}
on(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): this {
this.subscriber.on(this.to_strings(players));
return this;
}
off(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): this {
this.subscriber.off(this.to_strings(players));
return this;
}
players(): Array<number> {
return this.subscriber.channels().map(id => parseInt(id));
}
private to_strings(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): Array<string> {
let result: Array<string> = [];
if (!(players instanceof Array)) {
players = [players];
}
for (let player of players) {
if (typeof player === "number") {
result.push(player.toString());
}
else {
result.push(player.id.toString());
}
}
return result;
}
}
>>>>>>>
import {Batcher} from "batcher";
import {Publisher, Subscriber as RealSubscriber} from "pubsub";
// The player cache's Subscriber is just like a vanilla Subscriber, but can
// subscribe to and unsubscribe from numerical ids or whole Players. The
// function to query which players we are watching is called "players", not
// "channels".
let publisher = new Publisher<{[id: string]: PlayerCacheEntry}>();
export class Subscriber {
private subscriber: RealSubscriber<{[id: string]: PlayerCacheEntry}, string>;
constructor(callback: (player: PlayerCacheEntry) => void) {
this.subscriber = new publisher.Subscriber((id, player) => callback(player));
}
on(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): this {
this.subscriber.on(this.to_strings(players));
return this;
}
off(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): this {
this.subscriber.off(this.to_strings(players));
return this;
}
players(): Array<number> {
return this.subscriber.channels().map(id => parseInt(id));
}
private to_strings(players: number | PlayerCacheEntry | Array<number | PlayerCacheEntry>): Array<string> {
let result: Array<string> = [];
if (!(players instanceof Array)) {
players = [players];
}
for (let player of players) {
if (typeof player === "number") {
result.push(player.toString());
}
else {
result.push(player.id.toString());
}
}
return result;
}
}
<<<<<<<
let event_emitter = new TypedEventEmitter<{[id: string]: PlayerCacheEntry}>();
=======
let fetcher = null;
let fetch_queue: Array<FetchEntry> = [];
>>>>>>>
<<<<<<<
get("/termination-api/players", { "ids": queue.map(e => e.player_id).join('.') })
.then((players) => {
for (let idx = 0; idx < queue.length; ++idx) {
let player = players[idx];
let resolve = queue[idx].resolve;
let reject = queue[idx].reject;
let required_fields = queue[idx].required_fields;
if ('icon-url' in player) {
player.icon = player['icon-url']; /* handle stupid inconsistency in API */
}
delete active_fetches[player.id];
update(player);
if (required_fields) {
for (let field of required_fields) {
if (!(field in cache[player.id])) {
console.warn("Required field ", field, " was not resolved by fetch");
cache[player.id][field] = "[ERROR]";
=======
get("/termination-api/players", { "ids": queue.map(e => e.player_id).join('.') })
.then((players) => {
for (let idx = 0; idx < queue.length; ++idx) {
let player = players[idx];
let resolve = queue[idx].resolve;
let reject = queue[idx].reject;
let required_fields = queue[idx].required_fields;
if ('icon-url' in player) {
player.icon = player['icon-url']; /* handle stupid inconsistency in API */
}
delete active_fetches[player.id];
update(player);
if (required_fields) {
for (let field of required_fields) {
if (!(field in cache[player.id])) {
console.warn("Required field ", field, " was not resolved by fetch");
cache[player.id][field] = "[ERROR]";
}
}
}
try {
resolve(cache[player.id]);
} catch (e) {
console.error(e);
}
}
})
.catch((err) => {
console.error(err);
for (let idx = 0; idx < queue.length; ++idx) {
delete active_fetches[queue[idx].player_id];
try {
queue[idx].reject(err);
} catch (e) {
console.error(e);
}
>>>>>>>
get("/termination-api/players", { "ids": queue.map(e => e.player_id).join('.') })
.then((players) => {
for (let idx = 0; idx < queue.length; ++idx) {
let player = players[idx];
let resolve = queue[idx].resolve;
let reject = queue[idx].reject;
let required_fields = queue[idx].required_fields;
if ('icon-url' in player) {
player.icon = player['icon-url']; /* handle stupid inconsistency in API */
}
delete active_fetches[player.id];
update(player);
if (required_fields) {
for (let field of required_fields) {
if (!(field in cache[player.id])) {
console.warn("Required field ", field, " was not resolved by fetch");
cache[player.id][field] = "[ERROR]";
<<<<<<<
try {
resolve(cache[player.id]);
} catch (e) {
console.error(e);
}
}
})
.catch((err) => {
console.error(err);
for (let idx = 0; idx < queue.length; ++idx) {
delete active_fetches[queue[idx].player_id];
try {
queue[idx].reject(err);
} catch (e) {
console.error(e);
}
}
});
}
});
=======
}, 1);
}
});
}
>>>>>>>
try {
resolve(cache[player.id]);
} catch (e) {
console.error(e);
}
}
})
.catch((err) => {
console.error(err);
for (let idx = 0; idx < queue.length; ++idx) {
delete active_fetches[queue[idx].player_id];
try {
queue[idx].reject(err);
} catch (e) {
console.error(e);
}
}
});
}
}); |
<<<<<<<
const { newSource, position } = getCaretPositionFromSource(source);
if (!position) {
fail();
}
let sources = newSource;
if (!dontAddModuleDeclaration) {
// Add the module header and account for it in the cursor position
sources = ["module Test exposing (..)", "", ...newSource];
position.line += 2;
}
=======
const { newSources, position } = getCaretPositionFromSource(source);
>>>>>>>
const { newSources, position } = getCaretPositionFromSource(source);
if (!position) {
fail();
} |
<<<<<<<
import { Plugin, OutputOptions } from 'rollup';
import { Middleware } from 'polka';
export type Mode = 'start' | 'serve' | 'build';
export { Middleware };
export type OutputOption = OutputOptions | ((opts: OutputOptions) => OutputOptions);
export interface Options {
prod: boolean;
mode: Mode;
cwd: string;
public: string;
root: string;
out: string;
overlayDir: string;
aliases: Record<string, string>;
env: Record<string, string>;
middleware: Middleware[];
plugins: Plugin[];
output: OutputOption[];
}
=======
// Declarations used by plugins and WMR itself
declare module "wmr" {
import { Plugin, OutputOptions } from 'rollup';
import { Middleware } from 'polka';
export type Mode = 'start' | 'serve' | 'build';
export { Middleware };
export type OutputOption = OutputOptions | ((opts: OutputOptions) => OutputOptions);
export interface Options {
prod: boolean;
mode: Mode;
cwd: string;
root: string;
out: string;
overlayDir: string;
aliases: Record<string, string>;
env: Record<string, string>;
middleware: Middleware[];
plugins: Plugin[];
output: OutputOption[];
}
}
// Declarations used by WMR-based applications
declare interface ImportMeta {
hot?: {
accept(module: ({ module: ImportMeta }) => void): void;
invalidate(): void;
reject(): void;
}
}
declare interface NodeModule {
hot?: ImportMeta['hot'] | void;
}
declare var module: NodeModule;
declare module '*.css' { const url: string; export default url; }
declare module '*.scss' { const url: string; export default url; }
declare module '*.sass' { const url: string; export default url; }
declare module '*.styl' { const url: string; export default url; }
/** Maps authored classNames to their CSS Modules -suffixed generated classNames. */
interface Mapping { [key: string]: string; }
declare module '*.module.css' { const mapping: Mapping; export default mapping; }
declare module '*.module.scss' { const mapping: Mapping; export default mapping; }
declare module '*.module.sass' { const mapping: Mapping; export default mapping; }
declare module '*.module.styl' { const mapping: Mapping; export default mapping; }
// Import Prefixes
declare module 'json:';
declare module 'css:';
declare module 'url:' { const url: string; export default url; }
declare module 'bundle:' { const url: string; export default url; }
// Implicit URL Imports (see url-plugin)
declare module '*.png' { const url: string; export default url; }
declare module '*.jpg' { const url: string; export default url; }
declare module '*.jpeg' { const url: string; export default url; }
declare module '*.gif' { const url: string; export default url; }
declare module '*.webp' { const url: string; export default url; }
declare module '*.svg' { const url: string; export default url; }
declare module '*.mp4' { const url: string; export default url; }
declare module '*.ogg' { const url: string; export default url; }
declare module '*.mp3' { const url: string; export default url; }
declare module '*.wav' { const url: string; export default url; }
declare module '*.flac' { const url: string; export default url; }
declare module '*.aac' { const url: string; export default url; }
declare module '*.woff' { const url: string; export default url; }
declare module '*.woff2' { const url: string; export default url; }
declare module '*.eot' { const url: string; export default url; }
declare module '*.ttf' { const url: string; export default url; }
declare module '*.otf' { const url: string; export default url; }
>>>>>>>
// Declarations used by plugins and WMR itself
declare module "wmr" {
import { Plugin, OutputOptions } from 'rollup';
import { Middleware } from 'polka';
export type Mode = 'start' | 'serve' | 'build';
export { Middleware };
export type OutputOption = OutputOptions | ((opts: OutputOptions) => OutputOptions);
export interface Options {
prod: boolean;
mode: Mode;
cwd: string;
public: string;
root: string;
out: string;
overlayDir: string;
aliases: Record<string, string>;
env: Record<string, string>;
middleware: Middleware[];
plugins: Plugin[];
output: OutputOption[];
}
}
// Declarations used by WMR-based applications
declare interface ImportMeta {
hot?: {
accept(module: ({ module: ImportMeta }) => void): void;
invalidate(): void;
reject(): void;
}
}
declare interface NodeModule {
hot?: ImportMeta['hot'] | void;
}
declare var module: NodeModule;
declare module '*.css' { const url: string; export default url; }
declare module '*.scss' { const url: string; export default url; }
declare module '*.sass' { const url: string; export default url; }
declare module '*.styl' { const url: string; export default url; }
/** Maps authored classNames to their CSS Modules -suffixed generated classNames. */
interface Mapping { [key: string]: string; }
declare module '*.module.css' { const mapping: Mapping; export default mapping; }
declare module '*.module.scss' { const mapping: Mapping; export default mapping; }
declare module '*.module.sass' { const mapping: Mapping; export default mapping; }
declare module '*.module.styl' { const mapping: Mapping; export default mapping; }
// Import Prefixes
declare module 'json:';
declare module 'css:';
declare module 'url:' { const url: string; export default url; }
declare module 'bundle:' { const url: string; export default url; }
// Implicit URL Imports (see url-plugin)
declare module '*.png' { const url: string; export default url; }
declare module '*.jpg' { const url: string; export default url; }
declare module '*.jpeg' { const url: string; export default url; }
declare module '*.gif' { const url: string; export default url; }
declare module '*.webp' { const url: string; export default url; }
declare module '*.svg' { const url: string; export default url; }
declare module '*.mp4' { const url: string; export default url; }
declare module '*.ogg' { const url: string; export default url; }
declare module '*.mp3' { const url: string; export default url; }
declare module '*.wav' { const url: string; export default url; }
declare module '*.flac' { const url: string; export default url; }
declare module '*.aac' { const url: string; export default url; }
declare module '*.woff' { const url: string; export default url; }
declare module '*.woff2' { const url: string; export default url; }
declare module '*.eot' { const url: string; export default url; }
declare module '*.ttf' { const url: string; export default url; }
declare module '*.otf' { const url: string; export default url; } |
<<<<<<<
import { VimOption, BufferEvent, HyperspaceCoordinates, BufferType, BufferHide, BufferOption, Color, Buffer, Window, Tabpage, GenericCallback } from '../neovim/types'
=======
import { VimMode, VimOption, BufferEvent, HyperspaceCoordinates, BufferType, BufferHide, BufferOption, Color, Buffer, Window, Tabpage, GenericCallback, Keymap } from '../neovim/types'
>>>>>>>
import { VimOption, BufferEvent, HyperspaceCoordinates, BufferType, BufferHide, BufferOption, Color, Buffer, Window, Tabpage, GenericCallback, Keymap } from '../neovim/types'
<<<<<<<
=======
import { normalizeVimMode } from '../support/neovim-utils'
>>>>>>>
import { normalizeVimMode } from '../support/neovim-utils'
<<<<<<<
const api = ({ notify, request, onEvent, onCreateVim, onSwitchVim }: Neovim) => {
=======
const parseKeymap = (keymap: any): Keymap => keymap.reduce((res: Keymap, m: any) => {
const { lhs, rhs, sid, buffer, mode } = m
res.set(lhs, {
lhs,
rhs,
sid,
buffer,
mode: normalizeVimMode(mode),
// vim does not have booleans. these values are returned as either 0 or 1
expr: !!m.expr,
silent: !!m.silent,
nowait: !!m.nowait,
noremap: !!m.noremap,
})
return res
}, new Map())
export default ({ notify, request, onEvent, onCreateVim, onSwitchVim }: Neovim) => {
>>>>>>>
const parseKeymap = (keymap: any): Keymap => keymap.reduce((res: Keymap, m: any) => {
const { lhs, rhs, sid, buffer, mode } = m
res.set(lhs, {
lhs,
rhs,
sid,
buffer,
mode: normalizeVimMode(mode),
// vim does not have booleans. these values are returned as either 0 or 1
expr: !!m.expr,
silent: !!m.silent,
nowait: !!m.nowait,
noremap: !!m.noremap,
})
return res
}, new Map())
const api = ({ notify, request, onEvent, onCreateVim, onSwitchVim }: Neovim) => {
<<<<<<<
g, on, untilEvent, applyPatches, buffers, windows, tabs, options: readonlyOptions }
}
export default api
export type NeovimAPI = ReturnType<typeof api>
=======
g, on, untilEvent, applyPatches, buffers, windows, tabs, options:
readonlyOptions, registerAction, getKeymap }
}
>>>>>>>
g, on, untilEvent, applyPatches, buffers, windows, tabs, options:
readonlyOptions, registerAction, getKeymap }
}
export default api
export type NeovimAPI = ReturnType<typeof api> |
<<<<<<<
export enum SyncKind { None, Full, Incremental }
const servers = new Map<string, extensions.RPCServer>()
const serverCapabilities = new Map<string, any>()
=======
const servers = new Map<string, extensions.LanguageServer>()
>>>>>>>
export enum SyncKind { None, Full, Incremental }
const servers = new Map<string, extensions.RPCServer>()
<<<<<<<
const initServer = async (server: extensions.RPCServer, cwd: string, filetype: string) => {
=======
const initServer = async (server: extensions.LanguageServer, cwd: string, language: string) => {
>>>>>>>
const initServer = async (server: extensions.RPCServer, cwd: string, language: string) => {
<<<<<<<
export const onServerStart = (fn: (server: extensions.RPCServer) => void) => {
=======
export const onServerStart = (fn: (server: extensions.LanguageServer, language: string) => void) => {
>>>>>>>
export const onServerStart = (fn: (server: extensions.RPCServer, language: string) => void) => { |
<<<<<<<
export { ThemeProvider } from './components/ThemeProvider';
export { FormBlock } from './components/Form';
=======
export { ThemeProvider } from './components/ThemeProvider';
export { WrapperTag } from './components/WrapperTag';
>>>>>>>
export { ThemeProvider } from './components/ThemeProvider';
export { FormBlock } from './components/Form';
export { WrapperTag } from './components/WrapperTag'; |
<<<<<<<
import {Driver, DRIVERS, determineDriver} from './Driver'
=======
import {Driver} from './Driver'
import {PollyfillDriver} from './PolyfillDriver'
import {MemoryStorage} from './MemoryStorage'
import {CookieStorage} from './CookieStorage'
>>>>>>>
import {Driver, determineDriver} from './Driver'
import {PollyfillDriver} from './PolyfillDriver'
import {MemoryStorage} from './MemoryStorage'
import {CookieStorage} from './CookieStorage'
<<<<<<<
=======
export const DRIVERS = {
LOCAL: new PollyfillDriver(localStorage),
SESSION: new PollyfillDriver(sessionStorage),
MEMORY: new PollyfillDriver(new MemoryStorage()),
COOKIE: new Driver(new CookieStorage())
}
>>>>>>>
export const DRIVERS = {
LOCAL: new PollyfillDriver(localStorage),
SESSION: new PollyfillDriver(sessionStorage),
MEMORY: new PollyfillDriver(new MemoryStorage()),
COOKIE: new Driver(new CookieStorage())
} |
<<<<<<<
import { ERC20Token, OKB_ADDRESS, DAI_ADDRESS } from './token'
=======
import { ERC20TokenPredefinedData, DAI_ADDRESS } from './erc20'
>>>>>>>
import { ERC20Token, DAI_ADDRESS } from './token' |
<<<<<<<
import { OtherDetailsComponent } from './components/user/user-settings/other-details/other-details.component';
=======
import { AppEffectsModule } from './effects/index';
import { ComponentsModule } from './components/index';
import { SharedModule } from './shared/index';
import { CanActivateViaAuthGuard } from './guards/auth.guard';
import { TripsResolveGuard } from './guards/trips-resolve.guard';
import { InstagramAuthenticationCallbackComponent } from './shared/instagram-authentication-callback/instagram-authentication-callback.component';
>>>>>>>
import { AppEffectsModule } from './effects/index';
import { ComponentsModule } from './components/index';
import { SharedModule } from './shared/index';
import { CanActivateViaAuthGuard } from './guards/auth.guard';
import { TripsResolveGuard } from './guards/trips-resolve.guard';
import { InstagramAuthenticationCallbackComponent } from './shared/instagram-authentication-callback/instagram-authentication-callback.component';
import { OtherDetailsComponent } from './components/user/user-settings/other-details/other-details.component';
<<<<<<<
TrendingTripsComponent,
TripCommentComponent,
NewTripCommentComponent,
OtherDetailsComponent
=======
InstagramAuthenticationCallbackComponent
>>>>>>>
OtherDetailsComponent,
InstagramAuthenticationCallbackComponent |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.