type
stringclasses 7
values | content
stringlengths 4
9.55k
| repo
stringlengths 7
96
| path
stringlengths 4
178
| language
stringclasses 1
value |
|---|---|---|---|---|
FunctionDeclaration
|
export declare function deepMergeResource<
T extends string = string,
A extends object =(object | undefined),
R extends JSONAPIRelationshipsObject = (JSONAPIRelationshipsObject | undefined)
>(target: JSONAPIResource<T, A, R>, source: JSONAPIResource<T, A, R>): JSONAPIResource<T, A, R>;
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
FunctionDeclaration
|
export default function createJSONAPIReducer(reducerId: string, config: JSONAPISliceConfigsObject): {
reduce: Reducer;
RESOURCE: Readonly<string>;
updatesResources: () => PartialFSAMeta;
deletesResource: (resource: JSONAPIResourceIdentifier) => PartialFSAMeta;
createsRelationship: (...relations: (null | JSONAPIRelationshipUpdateConfig)[]) => PartialFSAMeta;
deletesRelationship: (...relations: (null | JSONAPIRelationshipUpdateConfig)[]) => PartialFSAMeta;
};
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
FunctionDeclaration
|
export declare function defineRelationship(
relatedResource: JSONAPIResourceIdentifier,
relationships?: JSONAPIRelationshipReferencesObject
): (null | JSONAPIRelationshipUpdateConfig);
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
InterfaceDeclaration
|
export interface JSONAPISliceConfig {
target?: string;
mergeMethod?(target: JSONAPIResource, source: JSONAPIResource): JSONAPIResource;
reducer?(resource: JSONAPIResource): JSONAPIResource;
}
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
InterfaceDeclaration
|
export interface JSONAPISliceConfigsObject {
[r: string]: JSONAPISliceConfig;
}
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
InterfaceDeclaration
|
export interface JSONAPIRelationshipReferencesObject {
[r: string]: JSONAPIRelationshipReference;
}
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
InterfaceDeclaration
|
export interface JSONAPIRelationshipUpdateConfig {
id: string;
type: string;
relationships: JSONAPIRelationshipReferencesObject;
}
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
TypeAliasDeclaration
|
export type JSONAPIRelationshipReference = string | JSONAPIResourceIdentifier | (string | JSONAPIResourceIdentifier)[];
|
FuelRats/fuelrats.com-redux-utils
|
types/redux-json-api.d.ts
|
TypeScript
|
ClassDeclaration
|
export class Commit {
id: string;
repoId: string;
shortMessage: string;
authorName: string;
authorEmail: string;
authorWhen: Date;
insertion: number;
deletion: number;
ignored: boolean;
}
|
eshockx/gitstatistics
|
src/main/angular-antd/src/app/domain/commit.ts
|
TypeScript
|
ArrowFunction
|
async subscription => {
let exchangeName: string
if (subscription.topicIdentifier) {
exchangeName = subscription.topicIdentifier
} else if (subscription.messageType) {
const messageName = new subscription.messageType().$name
exchangeName = messageName
await this.assertExchange(messageName)
} else {
throw new Error('Unable to bind exchange to queue - no topic information provided')
}
this.logger.debug('Binding exchange to queue.', { exchangeName, queueName: this.configuration.queueName })
await this.channel.bindQueue(this.configuration.queueName, exchangeName, '')
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
ClassDeclaration
|
/**
* A RabbitMQ transport adapter for @node-ts/bus.
*/
@injectable()
export class RabbitMqTransport implements Transport<RabbitMqMessage> {
private connection: Connection
private channel: Channel
private assertedExchanges: { [key: string]: boolean } = {}
private maxRetries: number
constructor (
@inject(BUS_RABBITMQ_INTERNAL_SYMBOLS.AmqpFactory)
private readonly connectionFactory: () => Promise<Connection>,
@inject(BUS_RABBITMQ_SYMBOLS.TransportConfiguration)
private readonly configuration: RabbitMqTransportConfiguration,
@inject(LOGGER_SYMBOLS.Logger) private readonly logger: Logger
) {
this.maxRetries = configuration.maxRetries || DEFAULT_MAX_RETRIES
}
async initialize (handlerRegistry: HandlerRegistry): Promise<void> {
this.logger.info('Initializing RabbitMQ transport')
this.connection = await this.connectionFactory()
this.channel = await this.connection.createChannel()
await this.bindExchangesToQueue(handlerRegistry)
this.logger.info('RabbitMQ transport initialized')
}
async dispose (): Promise<void> {
await this.channel.close()
await this.connection.close()
}
async publish<TEvent extends Event> (event: TEvent, messageAttributes?: MessageAttributes): Promise<void> {
await this.publishMessage(event, messageAttributes)
}
async send<TCommand extends Command> (command: TCommand, messageAttributes?: MessageAttributes): Promise<void> {
await this.publishMessage(command, messageAttributes)
}
async readNextMessage (): Promise<TransportMessage<RabbitMqMessage> | undefined> {
const rabbitMessage = await this.channel.get(this.configuration.queueName, { noAck: false })
if (rabbitMessage === false) {
return undefined
}
const payloadStr = rabbitMessage.content.toString('utf8')
const payload = JSON.parse(payloadStr) as MessageType
const attributes: MessageAttributes = {
correlationId: rabbitMessage.properties.correlationId as string,
attributes: rabbitMessage.properties.headers && rabbitMessage.properties.headers.attributes
? JSON.parse(rabbitMessage.properties.headers.attributes as string) as MessageAttributeMap
: {},
stickyAttributes: rabbitMessage.properties.headers && rabbitMessage.properties.headers.stickyAttributes
? JSON.parse(rabbitMessage.properties.headers.stickyAttributes as string) as MessageAttributeMap
: {}
}
return {
id: undefined,
domainMessage: payload,
raw: rabbitMessage,
attributes
}
}
async deleteMessage (message: TransportMessage<RabbitMqMessage>): Promise<void> {
this.logger.debug(
'Deleting message',
{
rawMessage: {
...message.raw,
content: message.raw.content.toString()
}
}
)
this.channel.ack(message.raw)
}
async returnMessage (message: TransportMessage<RabbitMqMessage>): Promise<void> {
const msg = JSON.parse(message.raw.content.toString())
const attempt = message.raw.fields.deliveryTag
const meta = { attempt, message: msg, rawMessage: message.raw }
if (attempt >= this.maxRetries) {
this.logger.debug('Message retries failed, sending to dead letter queue', meta)
this.channel.reject(message.raw, false)
} else {
this.logger.debug('Returning message', meta)
this.channel.nack(message.raw)
}
}
private async assertExchange (messageName: string): Promise<void> {
if (!this.assertedExchanges[messageName]) {
this.logger.debug('Asserting exchange', { messageName })
await this.channel.assertExchange(messageName, 'fanout', { durable: true })
this.assertedExchanges[messageName] = true
}
}
private async bindExchangesToQueue (handlerRegistry: HandlerRegistry): Promise<void> {
await this.createDeadLetterQueue()
await this.channel.assertQueue(
this.configuration.queueName,
{ durable: true, deadLetterExchange }
)
const subscriptionPromises = handlerRegistry.messageSubscriptions
.map(async subscription => {
let exchangeName: string
if (subscription.topicIdentifier) {
exchangeName = subscription.topicIdentifier
} else if (subscription.messageType) {
const messageName = new subscription.messageType().$name
exchangeName = messageName
await this.assertExchange(messageName)
} else {
throw new Error('Unable to bind exchange to queue - no topic information provided')
}
this.logger.debug('Binding exchange to queue.', { exchangeName, queueName: this.configuration.queueName })
await this.channel.bindQueue(this.configuration.queueName, exchangeName, '')
})
await Promise.all(subscriptionPromises)
}
/**
* Creates a dead letter exchange + queue, binds, and returns the
* dead letter exchange name
*/
private async createDeadLetterQueue (): Promise<void> {
await this.channel.assertExchange(deadLetterExchange, 'direct', { durable: true })
await this.channel.assertQueue(deadLetterQueue, { durable: true })
await this.channel.bindQueue(deadLetterQueue, deadLetterExchange, '')
}
private async publishMessage (
message: Message,
messageOptions: MessageAttributes = new MessageAttributes()
): Promise<void> {
await this.assertExchange(message.$name)
const payload = JSON.stringify(message)
this.channel.publish(message.$name, '', Buffer.from(payload), {
correlationId: messageOptions.correlationId,
headers: {
attributes: messageOptions.attributes ? JSON.stringify(messageOptions.attributes) : undefined,
stickyAttributes: messageOptions.stickyAttributes ? JSON.stringify(messageOptions.stickyAttributes) : undefined
}
})
}
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async initialize (handlerRegistry: HandlerRegistry): Promise<void> {
this.logger.info('Initializing RabbitMQ transport')
this.connection = await this.connectionFactory()
this.channel = await this.connection.createChannel()
await this.bindExchangesToQueue(handlerRegistry)
this.logger.info('RabbitMQ transport initialized')
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async dispose (): Promise<void> {
await this.channel.close()
await this.connection.close()
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async publish<TEvent extends Event> (event: TEvent, messageAttributes?: MessageAttributes): Promise<void> {
await this.publishMessage(event, messageAttributes)
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async send<TCommand extends Command> (command: TCommand, messageAttributes?: MessageAttributes): Promise<void> {
await this.publishMessage(command, messageAttributes)
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async readNextMessage (): Promise<TransportMessage<RabbitMqMessage> | undefined> {
const rabbitMessage = await this.channel.get(this.configuration.queueName, { noAck: false })
if (rabbitMessage === false) {
return undefined
}
const payloadStr = rabbitMessage.content.toString('utf8')
const payload = JSON.parse(payloadStr) as MessageType
const attributes: MessageAttributes = {
correlationId: rabbitMessage.properties.correlationId as string,
attributes: rabbitMessage.properties.headers && rabbitMessage.properties.headers.attributes
? JSON.parse(rabbitMessage.properties.headers.attributes as string) as MessageAttributeMap
: {},
stickyAttributes: rabbitMessage.properties.headers && rabbitMessage.properties.headers.stickyAttributes
? JSON.parse(rabbitMessage.properties.headers.stickyAttributes as string) as MessageAttributeMap
: {}
}
return {
id: undefined,
domainMessage: payload,
raw: rabbitMessage,
attributes
}
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async deleteMessage (message: TransportMessage<RabbitMqMessage>): Promise<void> {
this.logger.debug(
'Deleting message',
{
rawMessage: {
...message.raw,
content: message.raw.content.toString()
}
}
)
this.channel.ack(message.raw)
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
async returnMessage (message: TransportMessage<RabbitMqMessage>): Promise<void> {
const msg = JSON.parse(message.raw.content.toString())
const attempt = message.raw.fields.deliveryTag
const meta = { attempt, message: msg, rawMessage: message.raw }
if (attempt >= this.maxRetries) {
this.logger.debug('Message retries failed, sending to dead letter queue', meta)
this.channel.reject(message.raw, false)
} else {
this.logger.debug('Returning message', meta)
this.channel.nack(message.raw)
}
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
private async assertExchange (messageName: string): Promise<void> {
if (!this.assertedExchanges[messageName]) {
this.logger.debug('Asserting exchange', { messageName })
await this.channel.assertExchange(messageName, 'fanout', { durable: true })
this.assertedExchanges[messageName] = true
}
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
private async bindExchangesToQueue (handlerRegistry: HandlerRegistry): Promise<void> {
await this.createDeadLetterQueue()
await this.channel.assertQueue(
this.configuration.queueName,
{ durable: true, deadLetterExchange }
)
const subscriptionPromises = handlerRegistry.messageSubscriptions
.map(async subscription => {
let exchangeName: string
if (subscription.topicIdentifier) {
exchangeName = subscription.topicIdentifier
} else if (subscription.messageType) {
const messageName = new subscription.messageType().$name
exchangeName = messageName
await this.assertExchange(messageName)
} else {
throw new Error('Unable to bind exchange to queue - no topic information provided')
}
this.logger.debug('Binding exchange to queue.', { exchangeName, queueName: this.configuration.queueName })
await this.channel.bindQueue(this.configuration.queueName, exchangeName, '')
})
await Promise.all(subscriptionPromises)
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
/**
* Creates a dead letter exchange + queue, binds, and returns the
* dead letter exchange name
*/
private async createDeadLetterQueue (): Promise<void> {
await this.channel.assertExchange(deadLetterExchange, 'direct', { durable: true })
await this.channel.assertQueue(deadLetterQueue, { durable: true })
await this.channel.bindQueue(deadLetterQueue, deadLetterExchange, '')
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
MethodDeclaration
|
private async publishMessage (
message: Message,
messageOptions: MessageAttributes = new MessageAttributes()
): Promise<void> {
await this.assertExchange(message.$name)
const payload = JSON.stringify(message)
this.channel.publish(message.$name, '', Buffer.from(payload), {
correlationId: messageOptions.correlationId,
headers: {
attributes: messageOptions.attributes ? JSON.stringify(messageOptions.attributes) : undefined,
stickyAttributes: messageOptions.stickyAttributes ? JSON.stringify(messageOptions.stickyAttributes) : undefined
}
})
}
|
Zehelein/bus
|
packages/bus-rabbitmq/src/rabbitmq-transport.ts
|
TypeScript
|
ArrowFunction
|
ref => ref.where('userId', '==', this.localStorage.getItem('currentUser'))
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
ArrowFunction
|
ref => ref.where('shared', 'array-contains', this.localStorage.getItem('currentUserEmail'))
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
ClassDeclaration
|
@Injectable({
providedIn: 'root'
})
export class FirestoreService {
private collection: string;
constructor(
private firestore: AngularFirestore,
@Inject('LOCALSTORAGE') private localStorage: Storage
) {
this.collection = 'draw';
}
public create(canvas) {
return this.firestore.collection(this.collection).add({
canvas: canvas,
userId: this.localStorage.getItem('currentUser'),
displayName: this.localStorage.getItem('currentUserName'),
shared: []
});
}
public getById(documentId: string) {
return this.firestore.collection(this.collection).doc(documentId).valueChanges();
}
public get() {
return this.firestore.collection(this.collection, ref => ref.where('userId', '==', this.localStorage.getItem('currentUser')))
.valueChanges({ idField: 'docId'});
}
public sharedWithMe() {
return this.firestore.collection(this.collection, ref => ref.where('shared', 'array-contains', this.localStorage.getItem('currentUserEmail')))
.valueChanges({ idField: 'docId'});
}
public update(id: string, data: Draw) {
return this.firestore.collection(this.collection).doc(id).set(data);
}
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
InterfaceDeclaration
|
interface Draw {
docId: string;
userId: string;
displayName: String;
canvas: any;
shared: Array<string>;
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
MethodDeclaration
|
public create(canvas) {
return this.firestore.collection(this.collection).add({
canvas: canvas,
userId: this.localStorage.getItem('currentUser'),
displayName: this.localStorage.getItem('currentUserName'),
shared: []
});
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
MethodDeclaration
|
public getById(documentId: string) {
return this.firestore.collection(this.collection).doc(documentId).valueChanges();
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
MethodDeclaration
|
public get() {
return this.firestore.collection(this.collection, ref => ref.where('userId', '==', this.localStorage.getItem('currentUser')))
.valueChanges({ idField: 'docId'});
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
MethodDeclaration
|
public sharedWithMe() {
return this.firestore.collection(this.collection, ref => ref.where('shared', 'array-contains', this.localStorage.getItem('currentUserEmail')))
.valueChanges({ idField: 'docId'});
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
MethodDeclaration
|
public update(id: string, data: Draw) {
return this.firestore.collection(this.collection).doc(id).set(data);
}
|
levapm/pencil-test
|
src/app/core/services/database.service.ts
|
TypeScript
|
FunctionDeclaration
|
function LabeledValue({ label, value }: Props): React.ReactElement {
return (
<div className={styles.wrapper}>
<strong className={styles.label}>{label}</strong>
<span className={styles.value}>{value || '–'}
|
Sukriva/open-city-profile-ui
|
src/common/labeledValue/LabeledValue.tsx
|
TypeScript
|
TypeAliasDeclaration
|
type Props = {
label: string;
value: string | null | undefined;
};
|
Sukriva/open-city-profile-ui
|
src/common/labeledValue/LabeledValue.tsx
|
TypeScript
|
ArrowFunction
|
(): ReturnedFunc => {
const dispatcher = useDispatch();
return ({ target }: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
dispatcher(ReduxFormsActions.setErrorInFormField(AllFormsTypes.MESSAGE, target.id as MessageFormInputs, false));
dispatcher(ReduxFormsActions.setFieldInMessageForm(target.id as MessageFormInputs, target.value));
};
}
|
Milosz08/ReactJS_Web_Application_Digititles_Imagine
|
src/hooks/footer/useFooterFormChangeState.ts
|
TypeScript
|
ArrowFunction
|
({ target }: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
dispatcher(ReduxFormsActions.setErrorInFormField(AllFormsTypes.MESSAGE, target.id as MessageFormInputs, false));
dispatcher(ReduxFormsActions.setFieldInMessageForm(target.id as MessageFormInputs, target.value));
}
|
Milosz08/ReactJS_Web_Application_Digititles_Imagine
|
src/hooks/footer/useFooterFormChangeState.ts
|
TypeScript
|
TypeAliasDeclaration
|
type ReturnedFunc = ({ target }: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
|
Milosz08/ReactJS_Web_Application_Digititles_Imagine
|
src/hooks/footer/useFooterFormChangeState.ts
|
TypeScript
|
FunctionDeclaration
|
export default function App() {
return (
<html lang="en">
<head>
<meta charSet="utf-8" />
<meta name="viewport" content="width=device-width,initial-scale=1" />
<Meta />
<Links />
{typeof document === "undefined" ? "__STYLES__" : null}
</head>
<body>
<Outlet />
<ScrollRestoration />
<Scripts />
<LiveReload />
</body>
</html>
);
}
|
BasixKOR/remix
|
examples/styled-components/app/root.tsx
|
TypeScript
|
ArrowFunction
|
() => {
const mutator = new FloatingNonuniformMutation();
test('Generation test', () => {
const ind = new FloatingIndividual([2, 4, 5, 8], new NumericRange(0, 9));
const newInd = new FloatingIndividual('');
for (let i = 0; i < 1000; i++) {
newInd.deepCopy(ind);
expect(newInd.genotype).toEqual(ind.genotype);
mutator.mutate(newInd, 0.99);
expect(newInd.range).toEqual(ind.range);
newInd.forEach(gene => expect(NumericRange.isValueInRange(gene, newInd.range)).toBeTruthy());
}
});
}
|
GeneticsJS/GeneticsJS
|
src/__tests__/mutation/numeric/floating/FloatingNonUniformMutation.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
const ind = new FloatingIndividual([2, 4, 5, 8], new NumericRange(0, 9));
const newInd = new FloatingIndividual('');
for (let i = 0; i < 1000; i++) {
newInd.deepCopy(ind);
expect(newInd.genotype).toEqual(ind.genotype);
mutator.mutate(newInd, 0.99);
expect(newInd.range).toEqual(ind.range);
newInd.forEach(gene => expect(NumericRange.isValueInRange(gene, newInd.range)).toBeTruthy());
}
}
|
GeneticsJS/GeneticsJS
|
src/__tests__/mutation/numeric/floating/FloatingNonUniformMutation.test.ts
|
TypeScript
|
ArrowFunction
|
gene => expect(NumericRange.isValueInRange(gene, newInd.range)).toBeTruthy()
|
GeneticsJS/GeneticsJS
|
src/__tests__/mutation/numeric/floating/FloatingNonUniformMutation.test.ts
|
TypeScript
|
ArrowFunction
|
(): void => {
this.emitter.emit('tick', {});
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
ClassDeclaration
|
/**
* Value Object
*/
export class Interval implements IInterval {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
private static instance: Interval | undefined;
public static create(): Interval {
if (this.instance === undefined) {
this.instance = new Interval();
}
return this.instance;
}
private emitter = new NanoEvents<{tick: {}}>();
private constructor() {}
private items = new Map<unknown, unknown>();
private intervalId: number | undefined;
/**
* just run with `window.setInterval`
*/
private startTick() {
this.intervalId = window.setInterval((): void => {
this.emitter.emit('tick', {});
}, 30);
}
/**
* Weather running `window.setInterval`
*/
private isRunningTick(): boolean {
return this.intervalId !== undefined;
}
/**
* To stop running `window.setInterval`
*/
private stopTick(): void {
if (!this.isRunningTick()) {
return;
}
clearInterval(this.intervalId);
this.intervalId = undefined;
}
private hasItems(): boolean {
return this.items.size > 0;
}
/**
* whether item has
*/
private has(item: unknown) {
return this.items.has(item);
}
private add(item: unknown) {
this.items.set(item, item);
}
private remove(item: unknown) {
this.items.delete(item);
}
public async wait(
item: unknown,
condition: (onTick: (cb: () => void) => void) => Promise<void>,
): Promise<void> {
this.add(item);
if (this.has(item) && this.hasItems() && !this.isRunningTick()) {
this.startTick();
}
const onTick = this.emitter.on.bind(this.emitter, 'tick');
await condition(onTick);
this.remove(item);
if (!this.has(item) && !this.hasItems() && this.isRunningTick()) {
this.stopTick();
}
}
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
public static create(): Interval {
if (this.instance === undefined) {
this.instance = new Interval();
}
return this.instance;
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
/**
* just run with `window.setInterval`
*/
private startTick() {
this.intervalId = window.setInterval((): void => {
this.emitter.emit('tick', {});
}, 30);
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
/**
* Weather running `window.setInterval`
*/
private isRunningTick(): boolean {
return this.intervalId !== undefined;
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
/**
* To stop running `window.setInterval`
*/
private stopTick(): void {
if (!this.isRunningTick()) {
return;
}
clearInterval(this.intervalId);
this.intervalId = undefined;
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
private hasItems(): boolean {
return this.items.size > 0;
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
/**
* whether item has
*/
private has(item: unknown) {
return this.items.has(item);
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
private add(item: unknown) {
this.items.set(item, item);
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
private remove(item: unknown) {
this.items.delete(item);
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
MethodDeclaration
|
public async wait(
item: unknown,
condition: (onTick: (cb: () => void) => void) => Promise<void>,
): Promise<void> {
this.add(item);
if (this.has(item) && this.hasItems() && !this.isRunningTick()) {
this.startTick();
}
const onTick = this.emitter.on.bind(this.emitter, 'tick');
await condition(onTick);
this.remove(item);
if (!this.has(item) && !this.hasItems() && this.isRunningTick()) {
this.stopTick();
}
}
|
nju33/react-dayo
|
packages/core-dayo/src/entities/interval/interval.ts
|
TypeScript
|
FunctionDeclaration
|
export function WarningDeleteModal(
{ name, handleRemoveFromList, closeModal, title, description, isVisible }: WarningDeleteModal){
const [ isLoading, setIsLoading ] = useState(false)
return(
<ModalContainer selector="#modal">
<AnimatePresence exitBeforeEnter>
{ isVisible &&
<motion.div
className={styles.Modalbackground}
layout
initial={{ opacity: 0}}
|
GabrSobral/Carpe_Diem_ADMIN
|
src/components/WarningDeleteModal/index.tsx
|
TypeScript
|
InterfaceDeclaration
|
interface WarningDeleteModal{
name: string;
handleRemoveFromList: () => void | Promise<void>;
closeModal: () => void;
title: "a atividade" | "a categoria" | 'a pergunta' | "o arquivo";
description: string;
isVisible: boolean;
}
|
GabrSobral/Carpe_Diem_ADMIN
|
src/components/WarningDeleteModal/index.tsx
|
TypeScript
|
MethodDeclaration
|
isLoading ? <Loading type="spin" color="#fff" height={24} width={24}
|
GabrSobral/Carpe_Diem_ADMIN
|
src/components/WarningDeleteModal/index.tsx
|
TypeScript
|
ArrowFunction
|
({ interaction }) =>{
let queue:Queue = interaction.client.player.getQueue(interaction.guild);
if(queue == null) queue = interaction.client.player.createQueue(interaction.guild, {
textChannel: interaction.channel
});
interaction.followUp({embeds: [Embed(`Connected to Channel \`\` ${interaction.member.voice.channel.name} \`\``, 1)]});
queue.connect(interaction.member?.voice?.channel);
}
|
aquieover0/Aquie
|
src/Commands/Player/join.ts
|
TypeScript
|
FunctionDeclaration
|
function isProc(proc: MockProc | undefined): asserts proc is MockProc {
expect(proc).toBeInstanceOf(MockProc);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
(signal) => {
this.signalsSent.push(signal);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
const proc = new MockProc();
currentProc = proc;
return proc;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => restart$
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
jest.clearAllMocks();
log.messages.length = 0;
currentProc = undefined;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
(server: DevServer) => {
const subscription = server.run$.subscribe({
error(e) {
throw e;
},
});
subscriptions.push(subscription);
return subscription;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
if (currentProc) {
currentProc.removeAllListeners();
currentProc = undefined;
}
for (const sub of subscriptions) {
sub.unsubscribe();
}
subscriptions.length = 0;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
it('starts the dev server with the right options', () => {
run(new DevServer(defaultOptions)).unsubscribe();
expect(execa.node.mock.calls).toMatchInlineSnapshot(`
Array [
Array [
"some/script",
Array [
"foo",
"bar",
"--logging.json=false",
],
Object {
"env": Object {
"<inheritted process.env>": true,
"ELASTIC_APM_SERVICE_NAME": "kibana",
"isDevCliChild": "true",
},
"nodeOptions": Array [],
"stdio": "pipe",
},
],
]
`);
});
it('writes stdout and stderr lines to logger', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.stdout.write('hello ');
currentProc.stderr.write('something ');
currentProc.stdout.write('world\n');
currentProc.stderr.write('went wrong\n');
expect(log.messages).toMatchInlineSnapshot(`
Array [
Object {
"args": Array [
"hello world",
],
"type": "write",
},
Object {
"args": Array [
"something went wrong",
],
"type": "write",
},
]
`);
});
it('is ready when message sends SERVER_LISTENING message', () => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
let ready;
subscriptions.push(
server.isReady$().subscribe((_ready) => {
ready = _ready;
})
);
expect(ready).toBe(false);
currentProc.mockListening();
expect(ready).toBe(true);
});
it('is not ready when process exits', () => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
const ready$ = new Rx.BehaviorSubject<undefined | boolean>(undefined);
subscriptions.push(server.isReady$().subscribe(ready$));
currentProc.mockListening();
expect(ready$.getValue()).toBe(true);
currentProc.mockExit(0);
expect(ready$.getValue()).toBe(false);
});
it('logs about crashes when process exits with non-zero code', () => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
currentProc.mockExit(1);
expect(log.messages).toMatchInlineSnapshot(`
Array [
Object {
"args": Array [
"server crashed",
"with status code",
1,
],
"type": "bad",
},
]
`);
});
it('does not restart the server when process exits with 0 and stdio streams complete', async () => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
const initialProc = currentProc;
const ready$ = new Rx.BehaviorSubject<undefined | boolean>(undefined);
subscriptions.push(server.isReady$().subscribe(ready$));
currentProc.mockExit(0);
expect(ready$.getValue()).toBe(false);
expect(initialProc).toBe(currentProc); // no restart or the proc would have been updated
});
it('kills server and restarts when watcher says to', () => {
run(new DevServer(defaultOptions));
const initialProc = currentProc;
isProc(initialProc);
restart$.next();
expect(initialProc.signalsSent).toEqual(['SIGKILL']);
isProc(currentProc);
expect(currentProc).not.toBe(initialProc);
});
it('subscribes to sigint$, sigterm$, and processExit$ options', () => {
run(new DevServer(defaultOptions));
expect(sigint$.observers).toHaveLength(1);
expect(sigterm$.observers).toHaveLength(1);
expect(processExit$.observers).toHaveLength(1);
});
it('kills the server on sigint$ before listening', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
});
it('kills the server on processExit$', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
processExit$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
});
it('kills the server on sigterm$', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
sigterm$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
});
it('sends SIGINT to child process on sigint$ after listening', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT']);
});
it('sends SIGKILL to child process on double sigint$ after listening', () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT', 'SIGKILL']);
});
it('kills the server after sending SIGINT and gracefulTimeout is passed after listening', async () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT']);
await new Promise((resolve) => setTimeout(resolve, 1000));
expect(currentProc.signalsSent).toEqual(['SIGINT', 'SIGKILL']);
});
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions)).unsubscribe();
expect(execa.node.mock.calls).toMatchInlineSnapshot(`
Array [
Array [
"some/script",
Array [
"foo",
"bar",
"--logging.json=false",
],
Object {
"env": Object {
"<inheritted process.env>": true,
"ELASTIC_APM_SERVICE_NAME": "kibana",
"isDevCliChild": "true",
},
"nodeOptions": Array [],
"stdio": "pipe",
},
],
]
`);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.stdout.write('hello ');
currentProc.stderr.write('something ');
currentProc.stdout.write('world\n');
currentProc.stderr.write('went wrong\n');
expect(log.messages).toMatchInlineSnapshot(`
Array [
Object {
"args": Array [
"hello world",
],
"type": "write",
},
Object {
"args": Array [
"something went wrong",
],
"type": "write",
},
]
`);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
let ready;
subscriptions.push(
server.isReady$().subscribe((_ready) => {
ready = _ready;
})
);
expect(ready).toBe(false);
currentProc.mockListening();
expect(ready).toBe(true);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
(_ready) => {
ready = _ready;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
const ready$ = new Rx.BehaviorSubject<undefined | boolean>(undefined);
subscriptions.push(server.isReady$().subscribe(ready$));
currentProc.mockListening();
expect(ready$.getValue()).toBe(true);
currentProc.mockExit(0);
expect(ready$.getValue()).toBe(false);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
currentProc.mockExit(1);
expect(log.messages).toMatchInlineSnapshot(`
Array [
Object {
"args": Array [
"server crashed",
"with status code",
1,
],
"type": "bad",
},
]
`);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
async () => {
const server = new DevServer(defaultOptions);
run(server);
isProc(currentProc);
const initialProc = currentProc;
const ready$ = new Rx.BehaviorSubject<undefined | boolean>(undefined);
subscriptions.push(server.isReady$().subscribe(ready$));
currentProc.mockExit(0);
expect(ready$.getValue()).toBe(false);
expect(initialProc).toBe(currentProc); // no restart or the proc would have been updated
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
const initialProc = currentProc;
isProc(initialProc);
restart$.next();
expect(initialProc.signalsSent).toEqual(['SIGKILL']);
isProc(currentProc);
expect(currentProc).not.toBe(initialProc);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
expect(sigint$.observers).toHaveLength(1);
expect(sigterm$.observers).toHaveLength(1);
expect(processExit$.observers).toHaveLength(1);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
processExit$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
expect(currentProc.signalsSent).toEqual([]);
sigterm$.next();
expect(currentProc.signalsSent).toEqual(['SIGKILL']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
() => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT', 'SIGKILL']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ArrowFunction
|
async () => {
run(new DevServer(defaultOptions));
isProc(currentProc);
currentProc.mockListening();
expect(currentProc.signalsSent).toEqual([]);
sigint$.next();
expect(currentProc.signalsSent).toEqual(['SIGINT']);
await new Promise((resolve) => setTimeout(resolve, 1000));
expect(currentProc.signalsSent).toEqual(['SIGINT', 'SIGKILL']);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
ClassDeclaration
|
class MockProc extends EventEmitter {
public readonly signalsSent: string[] = [];
stdout = new PassThrough();
stderr = new PassThrough();
kill = jest.fn((signal) => {
this.signalsSent.push(signal);
});
mockExit(code: number) {
this.emit('exit', code, undefined);
// close stdio streams
this.stderr.end();
this.stdout.end();
}
mockListening() {
this.emit('message', ['SERVER_LISTENING'], undefined);
}
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
MethodDeclaration
|
mockExit(code: number) {
this.emit('exit', code, undefined);
// close stdio streams
this.stderr.end();
this.stdout.end();
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
MethodDeclaration
|
mockListening() {
this.emit('message', ['SERVER_LISTENING'], undefined);
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
MethodDeclaration
|
error(e) {
throw e;
}
|
AlexanderWert/kibana
|
src/dev/cli_dev_mode/dev_server.test.ts
|
TypeScript
|
FunctionDeclaration
|
/**
* Function to check if a version of request is supported by this library
*
* version is not supported if higher than the current one
* version is not supported if the major is different
* version is not supported if the version is in the exceptions array defined in config.json
*
* @param string version the version to check
* @param IVersionSupportConfig versionConfiguration override the default configuration only for this check
*
* @returns boolean true, if version is supported false otherwise
*/
function isSupported(version: string, versionConfiguration?: Types.IVersionSupportConfig): boolean {
versionConfiguration = versionConfiguration || Config.specificationVersion;
return (
!!Semver.valid(version) &&
Semver.diff(version, versionConfiguration.current) !== 'major' &&
Semver.lte(version, versionConfiguration.current) &&
versionConfiguration.exceptions.indexOf(version) === -1
);
}
|
romaric-juniet/requestNetwork
|
packages/request-logic/src/version.ts
|
TypeScript
|
FunctionDeclaration
|
export function* accountRootSaga() {
yield takeEvery(getType(actions.dummyAction), dummySaga)
}
|
Meyhem/generator-reactux
|
example/src/features/account/saga.ts
|
TypeScript
|
FunctionDeclaration
|
function* dummySaga() {
yield 0
}
|
Meyhem/generator-reactux
|
example/src/features/account/saga.ts
|
TypeScript
|
ArrowFunction
|
(r: any) => r instanceof HttpResponse
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrantProfile>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<RegistrantProfile>) => r.body as RegistrantProfile
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<GetSecurityQuestionsResponse>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<GetSecurityQuestionsResponse>) => r.body as GetSecurityQuestionsResponse
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<VerifySecurityQuestionsResponse>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<VerifySecurityQuestionsResponse>) => r.body as VerifySecurityQuestionsResponse
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<EvacuationFile>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<EvacuationFile>) => r.body as EvacuationFile
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<EvacuationFileSummary>>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<Array<EvacuationFileSummary>>) => r.body as Array<EvacuationFileSummary>
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<GetSecurityPhraseResponse>;
}
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
ArrowFunction
|
(r: StrictHttpResponse<GetSecurityPhraseResponse>) => r.body as GetSecurityPhraseResponse
|
SodhiA1/embc-ess-mod
|
responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts
|
TypeScript
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.