type stringclasses 7
values | content stringlengths 4 9.55k | repo stringlengths 7 96 | path stringlengths 4 178 | language stringclasses 1
value |
|---|---|---|---|---|
MethodDeclaration | /**
*
* @param event
*/
private _handleOpen(event: Event) {
this.didConnect = true;
this._eventManager.publishLocalEvent("WebsocketOpened", { timestamp: new Date().toISOString() });
if (this._opening) {
this._opening.resolve(true);
}
} | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
* @param event
*/
private _handleMessage(event: MessageEvent) {
let message: any;
try {
message = JSON.parse(event.data);
} catch (e) {
this._logger.error("socket onmessage: (not JSON)", event.data);
}
if (message) {
th... | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
* @param event
*/
private _handleError(event: Event) {
this._logger.log(`websocket onerror - readystate: ${this.readystates[this.webSocket.readyState]}`, event);
} | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
* @param event
*/
private _handleClose(event: CloseEvent) {
this.webSocket = undefined;
this._logger.log("WebSocket Connection closed.");
this._eventManager.publishLocalEvent("WebsocketClosed", { timestamp: new Date().toISOString() });
// This is the failed to con... | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
*/
private echo(): void {
this.send({
name: "echo",
payload: {},
publishedOn: new Date().toISOString(),
});
} | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
*/
private reconnect(): void {
if (!this.enabled) {
return;
}
let time = this.generateInterval(this.attempts);
setTimeout(() => {
this.attempts++;
this._logger.log(`reconnecting (${this.attempts}) ...`);
this.connect()
... | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
*
* @param name
*/
private mapEventName(name): string {
// TODO: make this configurable
// let eventAliasInfo: IEventMapping = {
// conversation: ["conversation", "chat"],
// conversationMessage: ["conversationMessage", "chatMessage"],
// profile... | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
MethodDeclaration | /**
* Map internal event structure to a defined interface ...
*/
private publishWebsocketEvent(event): void {
let mappedName = this.mapEventName(event.name);
switch (mappedName) {
case "conversation.delete":
{
this._eventManager.publishLocalEv... | comapi/comapi-sdk-js | src/webSocketManager.ts | TypeScript |
FunctionDeclaration |
function useToggle(id: string = ''): IUseToggle {
const [open, setOpen] = useState(false)
const show = () => setOpen(true)
const hide = () => setOpen(false)
const toggle = () => setOpen(!open)
return {
id,
open,
show,
hide,
toggle
}
} | whoisaf/macys-ui | src/hooks/useToggle.ts | TypeScript |
ArrowFunction |
() => setOpen(true) | whoisaf/macys-ui | src/hooks/useToggle.ts | TypeScript |
ArrowFunction |
() => setOpen(false) | whoisaf/macys-ui | src/hooks/useToggle.ts | TypeScript |
ArrowFunction |
() => setOpen(!open) | whoisaf/macys-ui | src/hooks/useToggle.ts | TypeScript |
InterfaceDeclaration | /**
* useToggle
* @description utility for controlling visibility of components
*/
export interface IUseToggle {
id?: string | null
open: boolean
show(): void
hide(): void
toggle(): void
} | whoisaf/macys-ui | src/hooks/useToggle.ts | TypeScript |
ArrowFunction |
() => {
this._domNode?.setClassName(this._visibleClassName);
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
ClassDeclaration |
export class ScrollbarVisibilityController extends Disposable {
private _visibility: ScrollbarVisibility;
private _visibleClassName: string;
private _invisibleClassName: string;
private _domNode: FastDomNode<HTMLElement> | null;
private _rawShouldBeVisible: boolean;
private _shouldBeVisible: boolean;
private _i... | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
public setVisibility(visibility: ScrollbarVisibility): void {
if (this._visibility !== visibility) {
this._visibility = visibility;
this._updateShouldBeVisible();
}
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration | // ----------------- Hide / Reveal
public setShouldBeVisible(rawShouldBeVisible: boolean): void {
this._rawShouldBeVisible = rawShouldBeVisible;
this._updateShouldBeVisible();
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
private _applyVisibilitySetting(): boolean {
if (this._visibility === ScrollbarVisibility.Hidden) {
return false;
}
if (this._visibility === ScrollbarVisibility.Visible) {
return true;
}
return this._rawShouldBeVisible;
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
private _updateShouldBeVisible(): void {
const shouldBeVisible = this._applyVisibilitySetting();
if (this._shouldBeVisible !== shouldBeVisible) {
this._shouldBeVisible = shouldBeVisible;
this.ensureVisibility();
}
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
public setIsNeeded(isNeeded: boolean): void {
if (this._isNeeded !== isNeeded) {
this._isNeeded = isNeeded;
this.ensureVisibility();
}
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
public setDomNode(domNode: FastDomNode<HTMLElement>): void {
this._domNode = domNode;
this._domNode.setClassName(this._invisibleClassName);
// Now that the flags & the dom node are in a consistent state, ensure the Hidden/Visible configuration
this.setShouldBeVisible(false);
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
public ensureVisibility(): void {
if (!this._isNeeded) {
// Nothing to be rendered
this._hide(false);
return;
}
if (this._shouldBeVisible) {
this._reveal();
} else {
this._hide(true);
}
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
private _reveal(): void {
if (this._isVisible) {
return;
}
this._isVisible = true;
// The CSS animation doesn't play otherwise
this._revealTimer.setIfNotSet(() => {
this._domNode?.setClassName(this._visibleClassName);
}, 0);
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
MethodDeclaration |
private _hide(withFadeAway: boolean): void {
this._revealTimer.cancel();
if (!this._isVisible) {
return;
}
this._isVisible = false;
this._domNode?.setClassName(this._invisibleClassName + (withFadeAway ? ' fade' : ''));
} | Balastrong/vscode | src/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.ts | TypeScript |
InterfaceDeclaration | /* eslint-enable @typescript-eslint/naming-convention */
interface IStatisticTrailEntryTodo {
todoId?: string;
bpmnTaskId: string;
bpmnLaneId: string;
desicionTaskBpmnTaskId?: string;
timeOverDueDate?: number;
} | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
InterfaceDeclaration |
interface IStatisticTrailEntryInstance {
instanceId: string;
jumpToBpmnTask?: string;
} | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
InterfaceDeclaration |
interface IStatisticTrailEntryUser {
instanceId: string;
} | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
InterfaceDeclaration |
export interface IStatisticTrailEntry {
todo?: IStatisticTrailEntryTodo;
instance?: IStatisticTrailEntryInstance;
user?: IStatisticTrailEntryUser;
process?: {};
} | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
InterfaceDeclaration |
export interface IStatisticRow {
statisticsId: string;
workspaceId: string;
processId: string;
details: IStatisticTrailEntry;
action: StatisticsAction;
userDetails?: IUserDetails;
userId: string;
createdAt: Date;
} | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
EnumDeclaration | /* eslint-disable @typescript-eslint/naming-convention */
export enum StatisticsAction {
// Process
processCreated = 1,
processEdited = 2,
processDeleted = 3,
// Instance
instanceStarted = 10,
instanceAborted = 11,
instanceIncomingMail = 12,
instanceOutgoingMail = 13,
instanceJumped = 14,
// Tod... | roXtra/processhub-sdk | src/data/statistics.ts | TypeScript |
FunctionDeclaration |
declare function PieChartSharp(props: any): any; | Douglas-CRVG/react-ionicons | lib/PieChartSharp.d.ts | TypeScript |
ArrowFunction |
(network: RenNetwork, timestamp = 0) => {
const forceV2 = timestamp > env.V2_DEPRECATION_TIME;
const cache = forceV2 ? renJsV2Cache : renJsCache;
if (!cache[network]) {
cache[network] = new RenJS(network, {
...renJsConfig,
useV2TransactionFormat: forceV2,
});
}
(window as any).renJS = cac... | CandlePlatforms/bridge | src/services/renJs.ts | TypeScript |
TypeAliasDeclaration |
type RenJSCache = Record<RenNetwork, RenJS>; | CandlePlatforms/bridge | src/services/renJs.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(3);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsClosed([raiden, partner]);
await waitBlock(closeBlock + settleTimeout - 1);
expect(getChannel(raiden, partner).state).toBe(ChannelState.closed);
await waitBlock(closeBlock + settleTimeout + 7);
exp... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
() => {
test('fails if channel exists', async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
raiden.store.dispatch(
channelOpen.request({ settleTimeout }, { tokenNetwork, partner: partner.address }),
);
expec... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
raiden.store.dispatch(
channelOpen.request({ settleTimeout }, { tokenNetwork, partner: partner.address }),
);
expect(getChannel(raiden, partner).state).toBe(... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
await ensureTokenIsMonitored(raiden);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
const openTx = makeTransaction(0);
tokenNetworkContract.openChannel.mockResolvedValue(openT... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
await ensureTokenIsMonitored(raiden);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
const openTx = makeTransaction();
tokenNetworkContract.openChannel.mockResolvedValue(openTx... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
expect(raiden.output).toContainEqual(
channelMonitored({ id }, { tokenNetwork, partner: partner.address }),
);
} | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const settleTimeoutEncoded = defaultAbiCoder.encode(['uint256'], [settleTimeout]);
const partner = makeAddress();
const raiden = await makeRaiden(undefined, false);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
// put a pre... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(i) => defaultAbiCoder.encode(['uint256'], [i]) | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await waitBlock(openBlock + 2);
await sleep();
const blockNumber = raiden.deps... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(deposit) => deposit.gt(0) | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const withdraw = BigNumber.from(300) as UInt<32>;
const withdrawEncoded = defaultAbiCoder.encode(['uint256'], [withdraw]);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(withdraw) => withdraw.gt(0) | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await waitBlock(closeBlock);
raiden.deps.provider.emit(
{},
makeLog({
... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(state) => state === ChannelState.closed | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(5);
const settleDataEncoded = defaultAbiCoder.encode(
['uint256', 'bytes32', 'uint256', 'bytes32'],
[Zero, HashZero, Zero, HashZero],
);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(toke... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
() => {
test('fails if channel.state !== "open" or missing', async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
raiden.store.dispatch(
channelDeposit.request({ deposit }, { tokenNetwork, partner: partner.address }),
);
await waitBlock();
expect(raiden.... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
raiden.store.dispatch(
channelDeposit.request({ deposit }, { tokenNetwork, partner: partner.address }),
);
await waitBlock();
expect(raiden.output).toContainEqual(
channelDeposit.failure(expect.any... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
const tokenContract = raiden.deps.getTokenContract(token);
tokenContract.balanceOf.mockResolvedValue(deposit.sub(1));
raiden.store.dispatch(
channelDeposit.... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(4);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
const tokenContract = raiden.deps.getTokenContract(token);
// not enough allowance, but not zero, need to reset
tokenContract.allowance.mockResolvedValue(deposit.s... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
const tokenContract = raiden.deps.getTokenContract(token);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
const approveTx = makeT... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(6);
const prevDeposit = BigNumber.from(330) as UInt<32>;
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsDeposited([raiden, partner], prevDeposit);
const tokenContract = raiden.deps.getTokenContract(token);
const tokenNetworkContract = raid... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
() => {
test('fails if there is no open channel with partner on tokenNetwork', async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureTokenIsMonitored(raiden);
raiden.store.dispatch(
channelClose.request(undefined, { tokenNetwork, partner: partner.addr... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureTokenIsMonitored(raiden);
raiden.store.dispatch(
channelClose.request(undefined, { tokenNetwork, partner: partner.address }),
);
expect(raiden.output).toContainEqual(
channelClose.failu... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsClosed([raiden, partner]);
raiden.store.dispatch(
channelClose.request(undefined, { tokenNetwork, partner: partner.address }),
);
expect(raiden.output).toContainEqual(
channelC... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
const closeTx = makeTransaction(0);
tokenNetworkContract.closeChannel.mockResolvedV... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(4);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsOpen([raiden, partner]);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
const closeTx = makeTransaction();
tokenNetworkContract.closeChannel.mockResolvedVal... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await ensureTransferUnlocked([partner, raiden]);
await ensureChannelIsClosed([partner, raiden])... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureTokenIsMonitored(raiden);
raiden.store.dispatch(
channelSettle.request(undefined, { tokenNetwork, partner: partner.address }),
);
expect(raiden.output).toContainEqual(
channelSettle.fai... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
await ensureChannelIsClosed([raiden, partner]);
raiden.store.dispatch(
channelSettle.request(undefined, { tokenNetwork, partner: partner.address }),
);
expect(raiden.output).toContainEqual(
channel... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(1);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsClosed([raiden, partner]);
await waitBlock(settleBlock + confirmationBlocks + 1);
const settleTx = makeTran... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(6);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
// despite we doing a transfer, leave default getChannelParticipantInfo mock which will
// tell we closed with BalanceProofZero, and ... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(8);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
raiden.store.dispatch(raidenConfigUpdate({ autoSettle: true }));
// deposit and make a transfer to partner
await ensureTransferUn... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(resolve) => {
tokenNetworkContract.settleChannel.mockImplementation(async () => {
ensureChannelIsSettled([raiden, partner]).then(resolve);
return settleTx;
});
} | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
ensureChannelIsSettled([raiden, partner]).then(resolve);
return settleTx;
} | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async ({}, participant, {}) => {
// from our perspective, partner closed the channel with wrong balanceProof
if (participant === raiden.address)
return [
Zero,
Zero,
false,
createBalanceHash(getBalanceProofFromEnvelopeMessage(locked)),
... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(8);
const [raiden, partner] = await makeRaidens(2);
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
raiden.store.dispatch(raidenConfigUpdate({ autoSettle: true }));
// deposit and make a transfer to partner
await ensureTransferUn... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
(resolve, reject) => {
tokenNetworkContract.settleChannel.mockImplementation(async () => {
ensureChannelIsSettled([raiden, partner]).then(resolve, reject);
return settleTx;
});
} | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
ensureChannelIsSettled([raiden, partner]).then(resolve, reject);
return settleTx;
} | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async ({}, participant, {}) => {
// from our perspective, partner closed the channel with wrong balanceProof
if (participant === partner.address)
return [
Zero,
Zero,
false,
createBalanceHash(getBalanceProofFromEnvelopeMessage(locked)),
... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
() => {
test('tx fails', async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
const { secretRegistryContract } = raiden.deps;
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await ens... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
const { secretRegistryContract } = raiden.deps;
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await ensureTransferPending([partner... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
const { secretRegistryContract } = raiden.deps;
const tokenNetworkContract = raiden.deps.getTokenNetworkContract(tokenNetwork);
await ensureChannelIsOpen([raiden, partner]);
await ensureTransferPending([partner... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(2);
const [raiden, partner] = await makeRaidens(2);
// enable autoSettle
raiden.store.dispatch(raidenConfigUpdate({ autoSettle: true }));
await ensureChannelIsClosed([raiden, partner]);
await waitBlock(settleBlock + 1);
await waitBlock(settleBlock + 2 * confirmationBloc... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ArrowFunction |
async () => {
expect.assertions(3);
const raiden = await makeRaiden(undefined, false);
raiden.store.dispatch(raidenConfigUpdate({ httpTimeout: 100 }));
await raiden.start();
// at first, receiving is enabled (since there's UDC deposit)
await waitBlock();
expect(raiden.config.caps?.[Capabilities.RECEIVE... | Ferret-san/light-client | raiden-ts/tests/integration/epics/channels.spec.ts | TypeScript |
ClassDeclaration | /** Represents a range of dates. */
export class DateRange {
constructor(private start: Date, private end: Date) {}
/** Checks if the given date is within this date range. */
public contains(date: Date): boolean {
const time = date.getTime();
if (this.start.getTime() > time || this.end.getTime() < time) ... | googleinterns/step37-2020 | src/main/angular/model/date_range.ts | TypeScript |
MethodDeclaration | /** Checks if the given date is within this date range. */
public contains(date: Date): boolean {
const time = date.getTime();
if (this.start.getTime() > time || this.end.getTime() < time) {
return false;
}
return true;
} | googleinterns/step37-2020 | src/main/angular/model/date_range.ts | TypeScript |
MethodDeclaration |
public getStart() {
return this.start;
} | googleinterns/step37-2020 | src/main/angular/model/date_range.ts | TypeScript |
MethodDeclaration |
public getEnd() {
return this.end;
} | googleinterns/step37-2020 | src/main/angular/model/date_range.ts | TypeScript |
ArrowFunction |
() => {
it('Should render Dark mode', () => {
const wrapper = renderer.create(
<Dark>
<p>Dark mode</p>
</Dark>,
);
expect(wrapper.toJSON()).toMatchSnapshot();
});
} | AuroraVenus/uikit-react | src/__test__/Inverse/Inverse.test.tsx | TypeScript |
ArrowFunction |
() => {
const wrapper = renderer.create(
<Dark>
<p>Dark mode</p>
</Dark>,
);
expect(wrapper.toJSON()).toMatchSnapshot();
} | AuroraVenus/uikit-react | src/__test__/Inverse/Inverse.test.tsx | TypeScript |
ArrowFunction |
() => {
it('Should render Light mode', () => {
const wrapper = renderer.create(
<Light>
<p>Light mode</p>
</Light>,
);
expect(wrapper.toJSON()).toMatchSnapshot();
});
} | AuroraVenus/uikit-react | src/__test__/Inverse/Inverse.test.tsx | TypeScript |
ArrowFunction |
() => {
const wrapper = renderer.create(
<Light>
<p>Light mode</p>
</Light>,
);
expect(wrapper.toJSON()).toMatchSnapshot();
} | AuroraVenus/uikit-react | src/__test__/Inverse/Inverse.test.tsx | TypeScript |
ArrowFunction |
async () => {
console.log('Trying to kill test setups in the CI 🦾 ...');
try {
const { stdout: serverStream } = await shell(`${process.cwd()}/scripts/getServerPid.sh`);
const { stdout: DBStream } = await shell(`${process.cwd()}/scripts/getDBPid.sh`);
PID_SERVER_IN_CONTAINER = serverStream.trim();
... | dvsa/cvs-svc-activities | scripts/destroyServices.ts | TypeScript |
ArrowFunction |
() => {
const token = process.env.JSON_WEB_TOKEN
? process.env.JSON_WEB_TOKEN
: sign(
{
sub: "admin@foo.com",
role_id: 1,
iss: "saltcorn@saltcorn",
aud: "saltcorn-mobile-app",
},
db.connectObj.jwt_secret
);
global.window = {
localSto... | christianhugoch/saltcorn | packages/saltcorn-data/tests/remote_query_helper.ts | TypeScript |
ArrowFunction |
(item: string) => {
if (item === "auth_jwt") return token;
return undefined;
} | christianhugoch/saltcorn | packages/saltcorn-data/tests/remote_query_helper.ts | TypeScript |
ArrowFunction |
async (view: any) => {
let copy = JSON.parse(JSON.stringify(view));
copy.id = undefined;
const url = `http://localhost:3000/viewedit/test/inserter`;
const token = global.window.localStorage.getItem("auth_jwt");
await axios.post(url, copy, {
headers: {
Authorization: `jwt ${token}`,
"X-Request... | christianhugoch/saltcorn | packages/saltcorn-data/tests/remote_query_helper.ts | TypeScript |
ArrowFunction |
async (id: number) => {
const url = `http://localhost:3000/viewedit/delete/${id}`;
const token = global.window.localStorage.getItem("auth_jwt");
await axios.post(
url,
{},
{
headers: {
Authorization: `jwt ${token}`,
"X-Requested-With": "XMLHttpRequest",
"X-Saltcorn-Clien... | christianhugoch/saltcorn | packages/saltcorn-data/tests/remote_query_helper.ts | TypeScript |
FunctionDeclaration | /**
* A helper function that doesn't traverse into nested blocks / statements by
* default.
*/
export function traverseShallow(
path: NodePath,
visitors: { [key: string]: Visitor },
): void {
// @ts-ignore
visit(path, { ...defaultVisitors, ...visitors });
} | TheRakeshPurohit/react-docgen | src/utils/traverse.ts | TypeScript |
TypeAliasDeclaration |
type Visitor = (path: NodePath) => unknown; | TheRakeshPurohit/react-docgen | src/utils/traverse.ts | TypeScript |
ClassDeclaration |
export declare class MetadataNetworkProperties {
readonly maxValueSize?: string | undefined;
/**
* @param maxValueSize - Maximum metadata value size.
*/
constructor(maxValueSize?: string | undefined);
} | ran-li2002/minty-server | node_modules/symbol-sdk/dist/src/model/network/MetadataNetworkProperties.d.ts | TypeScript |
FunctionDeclaration |
export default function langServerCoverageFunctionalTests({
getService,
getPageObjects,
}: FtrProviderContext) {
const testSubjects = getService('testSubjects');
const retry = getService('retry');
const esSupertest = getService('esSupertest');
const PageObjects = getPageObjects(['common', 'header', 'securi... | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
() => {
const repositoryListSelector = 'codeRepositoryList codeRepositoryItem';
before(async () => {
// Navigate to the code app.
await PageObjects.common.navigateToApp('code');
await PageObjects.header.waitUntilLoadingHasFinished();
// Prepare a git repository for the test
await... | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
async () => {
// Navigate to the code app.
await PageObjects.common.navigateToApp('code');
await PageObjects.header.waitUntilLoadingHasFinished();
// Prepare a git repository for the test
await PageObjects.code.fillImportRepositoryUrlInputBox(
'https://github.com/elastic/code-exa... | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
async () => {
const repositoryItems = await testSubjects.findAll(repositoryListSelector);
expect(repositoryItems).to.have.length(1);
expect(await repositoryItems[0].getVisibleText()).to.equal('elastic/code-examples_smoke');
// Wait for the index to start.
await retry.try(async ... | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
async () => {
expect(await testSubjects.exists('repositoryIndexOngoing')).to.be(true);
} | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
async () => {
expect(await testSubjects.exists('repositoryIndexDone')).to.be(true);
} | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
ArrowFunction |
async () => {
// Navigate to the code app.
await PageObjects.common.navigateToApp('code');
await PageObjects.header.waitUntilLoadingHasFinished();
// Clean up the imported repository
await PageObjects.code.clickDeleteRepositoryButton();
await retry.try(async () => {
expect(... | SquirtsMacintosh/kibana | x-pack/test/functional/apps/code/lang_server_coverage.ts | TypeScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.