@eleven-am/golem-client 0.0.0-stage → 0.1.1

package/dist/analysis.js

@@ -0,0 +1,471 @@
+import { Kind, OperationTypeNode, parse, print, visit, } from 'graphql';
+import { GolemDocumentError, GolemMultipleOperationsError, GolemNotLiveError } from './errors.js';
+const VERSION_FIELD = '_version';
+const TYPENAME_FIELD = '__typename';
+export function assertLive(analysis) {
+    const first = analysis.notLive[0];
+    if (first !== undefined) {
+        throw first;
+    }
+}
+export function streamRequest(stream, variables = {}) {
+    const picked = {};
+    for (const name of stream.variableNames) {
+        if (name in variables) {
+            picked[name] = variables[name];
+        }
+    }
+    return { query: stream.query, variables: picked };
+}
+const nameNode = (value) => ({ kind: Kind.NAME, value });
+const bareField = (name) => ({ kind: Kind.FIELD, name: nameNode(name) });
+const responseKey = (field) => (field.alias ?? field.name).value;
+const childPath = (path, field) => (path === '' ? responseKey(field) : `${path}.${responseKey(field)}`);
+const objectValue = (fields) => ({
+    kind: Kind.OBJECT,
+    fields: Object.entries(fields).map(([name, value]) => ({ kind: Kind.OBJECT_FIELD, name: nameNode(name), value })),
+});
+function conjunction(left, right) {
+    if (left === null) {
+        return right;
+    }
+    if (right === null) {
+        return left;
+    }
+    return objectValue({ AND: { kind: Kind.LIST, values: [left, right] } });
+}
+function argument(field, name) {
+    return field.arguments?.find((candidate) => candidate.name.value === name);
+}
+function filterScope(value) {
+    if (value === undefined || value.kind === Kind.NULL) {
+        return null;
+    }
+    if (value.kind === Kind.OBJECT) {
+        return value.fields.length === 0 ? null : value;
+    }
+    return value.kind === Kind.VARIABLE ? value : null;
+}
+function uniqueScope(model, value) {
+    if (value === undefined || value.kind !== Kind.OBJECT || value.fields.length === 0) {
+        return null;
+    }
+    const first = value.fields[0];
+    if (first === undefined || value.fields.length !== 1 || first.name.value !== model.cursorSelector) {
+        return null;
+    }
+    const key = first.value;
+    if (model.primaryKey.length === 1) {
+        const field = model.primaryKey[0];
+        if (field === undefined || key.kind === Kind.OBJECT) {
+            return null;
+        }
+        return objectValue({ [field]: objectValue({ equals: key }) });
+    }
+    if (key.kind !== Kind.OBJECT) {
+        return null;
+    }
+    const parts = {};
+    for (const part of key.fields) {
+        parts[part.name.value] = objectValue({ equals: part.value });
+    }
+    return objectValue(parts);
+}
+function applicableTo(fragment, models, manifest) {
+    const condition = fragment.typeCondition?.name.value;
+    if (condition === undefined || manifest.models[condition] === undefined) {
+        return models;
+    }
+    return models.includes(condition) ? [condition] : [];
+}
+function record(sink, error, key) {
+    if (sink !== null && !sink.notLive.has(key)) {
+        sink.notLive.set(key, error);
+    }
+}
+function injections(model) {
+    const names = [...model.primaryKey];
+    if (model.events !== null) {
+        names.push(VERSION_FIELD);
+    }
+    names.push(TYPENAME_FIELD);
+    return names;
+}
+function ensure(selections, names) {
+    const result = [...selections];
+    for (const name of names) {
+        const keyed = result.filter((selection) => selection.kind === Kind.FIELD && responseKey(selection) === name);
+        const taken = keyed.find((selection) => selection.name.value !== name);
+        if (taken !== undefined) {
+            throw new GolemDocumentError(`the response key ${name} is taken by ${taken.name.value}; golem needs ${name} unaliased on this selection`);
+        }
+        if (!keyed.some((selection) => (selection.directives ?? []).length === 0)) {
+            result.push(bareField(name));
+        }
+    }
+    return result;
+}
+function visitSet(set, models, scope, path, state, walk) {
+    const out = [];
+    for (const selection of set.selections) {
+        if (selection.kind === Kind.FIELD) {
+            out.push(visitField(selection, models, scope, path, state, walk));
+        }
+        else if (selection.kind === Kind.INLINE_FRAGMENT) {
+            const narrowed = applicableTo(selection, models, walk.manifest);
+            let inner = visitSet(selection.selectionSet, narrowed, scope, path, state, walk);
+            const only = narrowed[0];
+            if (models.length > 1 && narrowed.length === 1 && only !== undefined) {
+                const model = walk.manifest.models[only];
+                if (model !== undefined) {
+                    inner = ensure(inner, injections(model).filter((name) => name !== TYPENAME_FIELD));
+                }
+            }
+            out.push({ ...selection, selectionSet: { ...selection.selectionSet, selections: inner } });
+        }
+        else {
+            const definition = walk.fragments.get(selection.name.value);
+            if (definition === undefined) {
+                throw new GolemDocumentError(`fragment ${selection.name.value} is not defined in the document`);
+            }
+            if (walk.sink !== null) {
+                visitSet(definition.selectionSet, applicableTo(definition, models, walk.manifest), scope, path, state, walk);
+            }
+            out.push(selection);
+        }
+    }
+    return out;
+}
+function visitField(field, models, scope, path, state, walk) {
+    const name = field.name.value;
+    if (name.startsWith('__')) {
+        return field;
+    }
+    if (models.length === 0) {
+        return field;
+    }
+    const only = models[0];
+    if (models.length > 1 || only === undefined) {
+        throw new GolemDocumentError(`field ${name} is selected on a result that holds ${models.join(' or ')}; select it under a type condition`);
+    }
+    const model = walk.manifest.models[only];
+    const fields = state.fields.get(only);
+    if (model === undefined || fields === undefined) {
+        throw new GolemDocumentError(`the manifest has no model ${only}`);
+    }
+    const relation = model.relations[name];
+    if (relation !== undefined) {
+        state.nested = true;
+        return visitRelation(field, only, relation, scope, path, walk);
+    }
+    const computed = model.computed[name];
+    if (computed !== undefined && computed.length > 0) {
+        if (field.selectionSet === undefined) {
+            return field;
+        }
+        state.nested = true;
+        return { ...field, selectionSet: rows(field.selectionSet, computed, null, false, childPath(path, field), walk) };
+    }
+    fields.set(responseKey(field), field);
+    return field;
+}
+function visitRelation(field, owner, relation, scope, path, walk) {
+    const target = walk.manifest.models[relation.target];
+    if (target === undefined) {
+        throw new GolemDocumentError(`the manifest has no model ${relation.target}`);
+    }
+    if (field.selectionSet === undefined) {
+        return field;
+    }
+    const subject = `${owner}.${field.name.value}`;
+    if (relation.inverse === null) {
+        record(walk.sink, new GolemNotLiveError('hidden-inverse', subject, `${subject} is not live: the inverse relation of ${relation.target} is hidden, so rows of ${relation.target} cannot be tied to ${owner}`), `hidden-inverse|${subject}`);
+    }
+    const inverse = relation.inverse === null ? undefined : target.relations[relation.inverse];
+    let inverseFilter = null;
+    if (relation.inverse !== null && inverse !== undefined && scope !== null) {
+        inverseFilter = objectValue({ [relation.inverse]: objectValue({ [inverse.list ? 'some' : 'is']: scope }) });
+    }
+    const childScope = conjunction(filterScope(argument(field, 'where')?.value), inverseFilter);
+    return { ...field, selectionSet: rows(field.selectionSet, [relation.target], childScope, false, childPath(path, field), walk) };
+}
+function rows(set, models, scope, plain, path, walk) {
+    const order = walk.sink === null ? 0 : walk.sink.sequence++;
+    const state = { fields: new Map(models.map((model) => [model, new Map()])), nested: false };
+    let selections = visitSet(set, models, scope, path, state, walk);
+    const single = models.length === 1 ? walk.manifest.models[models[0] ?? ''] : undefined;
+    if (single !== undefined) {
+        selections = ensure(selections, injections(single));
+    }
+    else {
+        selections = ensure(selections, [TYPENAME_FIELD]);
+    }
+    register(models, scope, plain && !state.nested, order, path, state, walk);
+    return { ...set, selections };
+}
+function disagrees(draft, fields) {
+    for (const [responseName, field] of fields) {
+        const known = draft.fields.get(responseName);
+        if (known !== undefined && print(known) !== print(field)) {
+            return true;
+        }
+    }
+    return false;
+}
+function register(models, scope, patchable, order, path, state, walk) {
+    const sink = walk.sink;
+    if (sink === null) {
+        return;
+    }
+    for (const name of models) {
+        const model = walk.manifest.models[name];
+        const fields = state.fields.get(name);
+        if (model === undefined || fields === undefined) {
+            throw new GolemDocumentError(`the manifest has no model ${name}`);
+        }
+        if (model.events === null) {
+            record(sink, new GolemNotLiveError('model-without-events', name, `${name} is not live: the model has no events; declare Subscriptions on ${name} or use a static query`), `model-without-events|${name}`);
+            continue;
+        }
+        const base = `${model.events}|${scope === null ? '' : print(scope)}`;
+        let key = base;
+        let draft = sink.streams.get(key);
+        for (let copy = 1; draft !== undefined && disagrees(draft, fields); copy++) {
+            key = `${base}#${copy}`;
+            draft = sink.streams.get(key);
+        }
+        if (draft === undefined) {
+            draft = { key, model: name, eventsRoot: model.events, patchable, scope, order, fields: new Map(), paths: new Set() };
+            sink.streams.set(key, draft);
+        }
+        else {
+            draft.patchable &&= patchable;
+        }
+        draft.paths.add(path);
+        for (const [responseName, field] of fields) {
+            draft.fields.set(responseName, field);
+        }
+    }
+}
+function collectVariables(node) {
+    const names = new Set();
+    visit(node, {
+        Variable(variable) {
+            names.add(variable.name.value);
+        },
+    });
+    return names;
+}
+function finish(draft, manifest, operation) {
+    const model = manifest.models[draft.model];
+    if (model === undefined) {
+        throw new GolemDocumentError(`the manifest has no model ${draft.model}`);
+    }
+    const entity = ensure([...draft.fields.values()], injections(model));
+    const entitySet = { kind: Kind.SELECTION_SET, selections: entity };
+    const identity = model.primaryKey.length > 1
+        ? { ...bareField('id'), selectionSet: { kind: Kind.SELECTION_SET, selections: model.primaryKey.map(bareField) } }
+        : bareField('id');
+    const eventFields = [...['eventID', 'version', 'type'].map(bareField), identity];
+    eventFields.push({ ...bareField('entity'), selectionSet: entitySet });
+    const root = {
+        ...bareField(draft.eventsRoot),
+        arguments: draft.scope === null
+            ? []
+            : [{ kind: Kind.ARGUMENT, name: nameNode('where'), value: draft.scope }],
+        selectionSet: { kind: Kind.SELECTION_SET, selections: eventFields },
+    };
+    const body = { kind: Kind.SELECTION_SET, selections: [root] };
+    const used = collectVariables(body);
+    const definitions = (operation.variableDefinitions ?? []).filter((definition) => used.has(definition.variable.name.value));
+    const document = {
+        kind: Kind.DOCUMENT,
+        definitions: [
+            {
+                kind: Kind.OPERATION_DEFINITION,
+                operation: 'subscription',
+                variableDefinitions: definitions,
+                selectionSet: body,
+            },
+        ],
+    };
+    return {
+        key: draft.key,
+        model: draft.model,
+        eventsRoot: draft.eventsRoot,
+        patchable: draft.patchable,
+        scope: draft.scope === null ? 'policy-only' : 'exact',
+        paths: [...draft.paths].sort(),
+        query: print(document),
+        variableNames: [...used].sort(),
+    };
+}
+function visitRootSet(set, walk) {
+    const out = [];
+    for (const selection of set.selections) {
+        if (selection.kind === Kind.FIELD) {
+            out.push(visitRoot(selection, walk));
+        }
+        else if (selection.kind === Kind.INLINE_FRAGMENT) {
+            out.push({ ...selection, selectionSet: { ...selection.selectionSet, selections: visitRootSet(selection.selectionSet, walk) } });
+        }
+        else {
+            const definition = walk.fragments.get(selection.name.value);
+            if (definition === undefined) {
+                throw new GolemDocumentError(`fragment ${selection.name.value} is not defined in the document`);
+            }
+            if (walk.sink !== null) {
+                visitRootSet(definition.selectionSet, walk);
+            }
+            out.push(selection);
+        }
+    }
+    return out;
+}
+function visitRoot(field, walk) {
+    const name = field.name.value;
+    if (name.startsWith('__')) {
+        return field;
+    }
+    const root = walk.manifest.roots[name];
+    if (root === undefined) {
+        throw new GolemDocumentError(`${name} is not a root in the manifest`);
+    }
+    if (root.kind === 'generated') {
+        const modelName = root.models[0];
+        const model = modelName === undefined ? undefined : walk.manifest.models[modelName];
+        if (modelName === undefined || model === undefined) {
+            throw new GolemDocumentError(`the manifest root ${name} names no model`);
+        }
+        if (root.shape !== 'rows' && root.shape !== 'row' && root.shape !== 'deletedRow') {
+            record(walk.sink, new GolemNotLiveError('non-row-root', name, `${name} is not live: its result shape is ${root.shape}, not model rows`), `non-row-root|${name}`);
+            return field;
+        }
+        if (field.selectionSet === undefined) {
+            return field;
+        }
+        const where = argument(field, 'where')?.value;
+        const scope = root.shape === 'rows' ? filterScope(where) : uniqueScope(model, where);
+        markNullable(field, root, walk);
+        const plain = (field.arguments ?? []).every((candidate) => candidate.name.value === 'where');
+        return { ...field, selectionSet: rows(field.selectionSet, [modelName], scope, plain, responseKey(field), walk) };
+    }
+    if (root.models.length === 0 || field.selectionSet === undefined) {
+        record(walk.sink, new GolemNotLiveError('opaque-root-without-models', name, `${name} is not live: the custom root's result holds no model rows`), `opaque-root-without-models|${name}`);
+        return field;
+    }
+    markNullable(field, root, walk);
+    return { ...field, selectionSet: rows(field.selectionSet, root.models, null, false, responseKey(field), walk) };
+}
+function markNullable(field, root, walk) {
+    if ((root.shape === 'row' || root.shape === 'deletedRow') && root.nullable && walk.sink !== null) {
+        walk.sink.nullable.add(responseKey(field));
+    }
+}
+function rewriteFragment(definition, walk) {
+    const condition = definition.typeCondition.name.value;
+    if (condition === 'Query') {
+        return { ...definition, selectionSet: { ...definition.selectionSet, selections: visitRootSet(definition.selectionSet, walk) } };
+    }
+    if (walk.manifest.models[condition] === undefined) {
+        return definition;
+    }
+    return { ...definition, selectionSet: rows(definition.selectionSet, [condition], null, false, '', walk) };
+}
+export function operationOf(document, kind) {
+    const operations = document.definitions.filter((definition) => definition.kind === Kind.OPERATION_DEFINITION);
+    if (operations.length > 1) {
+        throw new GolemMultipleOperationsError(operations.length);
+    }
+    const operation = operations[0];
+    if (operation === undefined) {
+        throw new GolemDocumentError('the document holds no operation');
+    }
+    if (operation.operation !== kind) {
+        throw new GolemDocumentError(`only ${kind} operations are analysed here; got ${operation.operation}`);
+    }
+    return operation;
+}
+function fragmentsOf(document) {
+    const fragments = new Map();
+    for (const definition of document.definitions) {
+        if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+            fragments.set(definition.name.value, definition);
+        }
+    }
+    return fragments;
+}
+function analyse(document, manifest) {
+    const operation = operationOf(document, OperationTypeNode.QUERY);
+    const fragments = fragmentsOf(document);
+    const sink = { streams: new Map(), notLive: new Map(), nullable: new Set(), sequence: 0 };
+    const live = { manifest, fragments, sink };
+    const silent = { manifest, fragments, sink: null };
+    const rewrittenOperation = {
+        ...operation,
+        selectionSet: { ...operation.selectionSet, selections: visitRootSet(operation.selectionSet, live) },
+    };
+    const definitions = document.definitions.map((definition) => {
+        if (definition === operation) {
+            return rewrittenOperation;
+        }
+        if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+            return rewriteFragment(definition, silent);
+        }
+        return definition;
+    });
+    const rewritten = { ...document, definitions };
+    const notLive = [...sink.notLive.values()];
+    return {
+        document: rewritten,
+        query: print(rewritten),
+        nullableRoots: sink.nullable,
+        streams: notLive.length > 0 ? [] : [...sink.streams.values()].sort((left, right) => left.order - right.order).map((draft) => finish(draft, manifest, operation)),
+        notLive,
+        live: notLive.length === 0,
+    };
+}
+export class DocumentAnalyzer {
+    manifest;
+    byText = new Map();
+    byNode = new WeakMap();
+    constructor(manifest) {
+        this.manifest = manifest;
+    }
+    analyze(document) {
+        if (typeof document === 'string') {
+            let analysis = this.byText.get(document);
+            if (analysis === undefined) {
+                analysis = analyse(parse(document), this.manifest);
+                this.byText.set(document, analysis);
+            }
+            return analysis;
+        }
+        let analysis = this.byNode.get(document);
+        if (analysis === undefined) {
+            analysis = analyse(document, this.manifest);
+            this.byNode.set(document, analysis);
+        }
+        return analysis;
+    }
+}
+export function analyzeMutation(document, manifest) {
+    const parsed = typeof document === 'string' ? parse(document) : document;
+    const operation = operationOf(parsed, OperationTypeNode.MUTATION);
+    const roots = [];
+    for (const selection of operation.selectionSet.selections) {
+        if (selection.kind !== Kind.FIELD) {
+            throw new GolemDocumentError('a mutation document selects its roots directly; fragments at the mutation root are not supported');
+        }
+        const name = selection.name.value;
+        if (name.startsWith('__')) {
+            continue;
+        }
+        const described = manifest.roots[name];
+        if (described === undefined) {
+            throw new GolemDocumentError(`${name} is not a root in the manifest`);
+        }
+        roots.push({ name, models: described.models });
+    }
+    return { query: print(parsed), roots };
+}

package/dist/client.d.ts

@@ -0,0 +1,49 @@
+import type { DocumentNode } from 'graphql';
+import type { QueryClient, QueryFunctionContext } from '@tanstack/query-core';
+import { DocumentAnalyzer } from './analysis.js';
+import { LiveSync } from './live.js';
+import type { ClientManifest } from './manifest.js';
+import { Mutations } from './mutations.js';
+import type { CredentialsGetter, SocketFactory } from './session.js';
+import { Transport } from './transport.js';
+export interface GolemClientOptions {
+    readonly queryClient: QueryClient;
+    readonly url: string;
+    readonly manifest: ClientManifest;
+    readonly credentials?: CredentialsGetter;
+    readonly createSocket?: SocketFactory;
+    readonly fetch?: typeof globalThis.fetch;
+}
+export declare class GolemClient {
+    readonly queryClient: QueryClient;
+    readonly transport: Transport;
+    readonly live: LiveSync;
+    readonly mutations: Mutations;
+    readonly analyzer: DocumentAnalyzer;
+    private holds;
+    private startedByHolds;
+    constructor(options: GolemClientOptions);
+    queryOptions(document: DocumentNode | string, variables?: Readonly<Record<string, unknown>>): {
+        queryKey: readonly ["golem", string, Readonly<Record<string, unknown>>];
+        queryFn: (context: QueryFunctionContext) => Promise<unknown>;
+        meta: {
+            golem: import("./live.js").GolemQueryMeta;
+        };
+    };
+    infiniteQueryOptions(document: DocumentNode | string, variables?: Readonly<Record<string, unknown>>): {
+        queryKey: readonly ["golem", string, Readonly<Record<string, unknown>>, "infinite"];
+        queryFn: (context: QueryFunctionContext<readonly unknown[], import("./pagination.js").Cursor | null>) => Promise<unknown>;
+        initialPageParam: Readonly<Record<string, unknown>> | null;
+        getNextPageParam: (lastPage: unknown) => Readonly<Record<string, unknown>> | undefined;
+        meta: {
+            golem: import("./live.js").GolemQueryMeta;
+        };
+    };
+    staticQueryOptions(document: DocumentNode | string, variables?: Readonly<Record<string, unknown>>): {
+        queryKey: readonly ["golem", "static", string, Readonly<Record<string, unknown>>];
+        queryFn: (context: Pick<QueryFunctionContext, "signal">) => Promise<unknown>;
+    };
+    mutate<T = unknown>(document: DocumentNode | string, variables?: Readonly<Record<string, unknown>>, signal?: AbortSignal): Promise<T>;
+    attach(): () => void;
+    dispose(): void;
+}

package/dist/client.js

@@ -0,0 +1,77 @@
+import { DocumentAnalyzer } from './analysis.js';
+import { GolemConfigurationError } from './errors.js';
+import { LiveSync } from './live.js';
+import { Mutations } from './mutations.js';
+import { Transport } from './transport.js';
+const claimed = new WeakMap();
+export class GolemClient {
+    queryClient;
+    transport;
+    live;
+    mutations;
+    analyzer;
+    holds = 0;
+    startedByHolds = false;
+    constructor(options) {
+        if (options.queryClient === undefined || options.queryClient === null) {
+            throw new GolemConfigurationError('GolemClient needs the application QueryClient: pass queryClient');
+        }
+        if (claimed.has(options.queryClient)) {
+            throw new GolemConfigurationError('this QueryClient already belongs to a GolemClient; one QueryClient serves one GolemClient');
+        }
+        this.queryClient = options.queryClient;
+        this.transport = new Transport({
+            url: options.url,
+            manifest: options.manifest,
+            credentials: options.credentials,
+            createSocket: options.createSocket,
+            fetch: options.fetch,
+        });
+        this.analyzer = new DocumentAnalyzer(options.manifest);
+        this.live = new LiveSync({ queryClient: options.queryClient, transport: this.transport, manifest: options.manifest });
+        this.mutations = new Mutations({ queryClient: options.queryClient, transport: this.transport, manifest: options.manifest });
+        claimed.set(options.queryClient, this);
+    }
+    queryOptions(document, variables = {}) {
+        return this.live.options(this.analyzer.analyze(document), variables);
+    }
+    infiniteQueryOptions(document, variables = {}) {
+        return this.live.infiniteOptions(this.analyzer.analyze(document), variables);
+    }
+    staticQueryOptions(document, variables = {}) {
+        const analysis = this.analyzer.analyze(document);
+        return {
+            queryKey: ['golem', 'static', analysis.query, variables],
+            queryFn: (context) => this.transport.execute({ query: analysis.query, variables, signal: context.signal }),
+        };
+    }
+    mutate(document, variables, signal) {
+        return this.mutations.execute(document, variables, signal);
+    }
+    attach() {
+        this.holds++;
+        if (this.holds === 1 && !this.live.started) {
+            this.live.start();
+            this.startedByHolds = true;
+        }
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.holds--;
+            if (this.holds === 0 && this.startedByHolds) {
+                this.startedByHolds = false;
+                this.live.stop();
+            }
+        };
+    }
+    dispose() {
+        this.live.stop();
+        this.transport.dispose();
+        if (claimed.get(this.queryClient) === this) {
+            claimed.delete(this.queryClient);
+        }
+    }
+}

package/dist/coalescer.d.ts

@@ -0,0 +1,14 @@
+export declare const COALESCE_WINDOW_MS = 50;
+export declare const COALESCE_MAX_WAIT_MS = 500;
+export declare class Coalescer {
+    private readonly fire;
+    private readonly window;
+    private readonly maxWait;
+    private timer;
+    private firstRequestAt;
+    constructor(fire: () => void, window?: number, maxWait?: number);
+    get pending(): boolean;
+    request(): void;
+    flush(): void;
+    cancel(): void;
+}

package/dist/coalescer.js

@@ -0,0 +1,37 @@
+export const COALESCE_WINDOW_MS = 50;
+export const COALESCE_MAX_WAIT_MS = 500;
+export class Coalescer {
+    fire;
+    window;
+    maxWait;
+    timer;
+    firstRequestAt;
+    constructor(fire, window = COALESCE_WINDOW_MS, maxWait = COALESCE_MAX_WAIT_MS) {
+        this.fire = fire;
+        this.window = window;
+        this.maxWait = maxWait;
+    }
+    get pending() {
+        return this.timer !== undefined;
+    }
+    request() {
+        const now = Date.now();
+        this.firstRequestAt ??= now;
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        const remaining = this.firstRequestAt + this.maxWait - now;
+        this.timer = setTimeout(() => this.flush(), Math.max(0, Math.min(this.window, remaining)));
+    }
+    flush() {
+        this.cancel();
+        this.fire();
+    }
+    cancel() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        this.timer = undefined;
+        this.firstRequestAt = undefined;
+    }
+}