@sanity/cli 5.1.1-next.5 → 6.0.0-alpha.3

package/dist/util/validation/ __tests__/validateDocuments.test.js

@@ -0,0 +1,274 @@
+import { describe, expect, test } from 'vitest';
+import { DOCUMENT_VALIDATION_TIMEOUT, getReferenceIds, isValidId, levelValues, MAX_VALIDATION_CONCURRENCY, REFERENCE_INTEGRITY_BATCH_SIZE, shouldIncludeDocument } from '../validateDocumentsUtils';
+describe('validateDocumentsUtils', ()=>{
+    describe('constants', ()=>{
+        test('should have correct values', ()=>{
+            expect(DOCUMENT_VALIDATION_TIMEOUT).toBe(30_000);
+            expect(MAX_VALIDATION_CONCURRENCY).toBe(100);
+            expect(REFERENCE_INTEGRITY_BATCH_SIZE).toBe(100);
+            expect(levelValues).toEqual({
+                error: 0,
+                info: 2,
+                warning: 1
+            });
+        });
+    });
+    describe('getReferenceIds', ()=>{
+        test('should extract reference IDs from various document structures', ()=>{
+            const testCases = [
+                {
+                    doc: {
+                        author: {
+                            _ref: 'author-123',
+                            _type: 'reference'
+                        }
+                    },
+                    expected: [
+                        'author-123'
+                    ],
+                    name: 'simple reference'
+                },
+                {
+                    doc: {
+                        author: {
+                            _ref: 'author-123',
+                            _type: 'reference'
+                        },
+                        editor: {
+                            _ref: 'editor-456',
+                            _type: 'reference'
+                        }
+                    },
+                    expected: [
+                        'author-123',
+                        'editor-456'
+                    ],
+                    name: 'multiple references'
+                },
+                {
+                    doc: {
+                        authors: [
+                            {
+                                _ref: 'author-1',
+                                _type: 'reference'
+                            },
+                            {
+                                _ref: 'author-2',
+                                _type: 'reference'
+                            }
+                        ]
+                    },
+                    expected: [
+                        'author-1',
+                        'author-2'
+                    ],
+                    name: 'array of references'
+                },
+                {
+                    doc: {
+                        content: {
+                            sections: [
+                                {
+                                    author: {
+                                        _ref: 'nested-author',
+                                        _type: 'reference'
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    expected: [
+                        'nested-author'
+                    ],
+                    name: 'nested references'
+                },
+                {
+                    doc: {
+                        author: {
+                            _ref: 'same-id',
+                            _type: 'reference'
+                        },
+                        editor: {
+                            _ref: 'same-id',
+                            _type: 'reference'
+                        }
+                    },
+                    expected: [
+                        'same-id'
+                    ],
+                    name: 'duplicate references'
+                },
+                {
+                    doc: {
+                        content: 'Some content',
+                        title: 'Test'
+                    },
+                    expected: [],
+                    name: 'no references'
+                }
+            ];
+            for (const { doc, expected, name } of testCases){
+                const ids = getReferenceIds(doc);
+                expect(ids.size, `Failed for: ${name}`).toBe(expected.length);
+                for (const id of expected){
+                    expect(ids.has(id), `Missing ID ${id} for: ${name}`).toBe(true);
+                }
+            }
+        });
+        test.each([
+            [
+                'empty object',
+                {}
+            ],
+            [
+                'empty array',
+                []
+            ],
+            [
+                'null',
+                null
+            ],
+            [
+                'undefined',
+                undefined
+            ],
+            [
+                'string',
+                'string'
+            ],
+            [
+                'number',
+                123
+            ],
+            [
+                'boolean',
+                true
+            ]
+        ])('should return empty set for %s', (_, value)=>{
+            expect(getReferenceIds(value).size).toBe(0);
+        });
+    });
+    describe('isValidId', ()=>{
+        test.each([
+            [
+                'abc123',
+                true
+            ],
+            [
+                'ABC123',
+                true
+            ],
+            [
+                'doc-123',
+                true
+            ],
+            [
+                'doc_123',
+                true
+            ],
+            [
+                'doc.123',
+                true
+            ],
+            [
+                'doc_123-456.789',
+                true
+            ],
+            [
+                'a',
+                true
+            ],
+            [
+                '-invalid',
+                false
+            ],
+            [
+                '',
+                false
+            ],
+            [
+                123,
+                false
+            ],
+            [
+                null,
+                false
+            ],
+            [
+                undefined,
+                false
+            ],
+            [
+                {},
+                false
+            ],
+            [
+                [],
+                false
+            ]
+        ])('isValidId(%s) should return %s', (id, expected)=>{
+            expect(isValidId(id)).toBe(expected);
+        });
+    });
+    describe('shouldIncludeDocument', ()=>{
+        test.each([
+            [
+                'article',
+                true
+            ],
+            [
+                'myCustomType',
+                true
+            ],
+            [
+                'my-custom_type',
+                true
+            ],
+            [
+                'systemConfig',
+                true
+            ],
+            [
+                'sanityConfig',
+                true
+            ],
+            [
+                'insanity',
+                true
+            ],
+            [
+                'system.settings',
+                false
+            ],
+            [
+                'system.config',
+                false
+            ],
+            [
+                'system.user',
+                false
+            ],
+            [
+                'sanity.imageAsset',
+                false
+            ],
+            [
+                'sanity.fileAsset',
+                false
+            ],
+            [
+                'sanity.dashboard',
+                false
+            ]
+        ])('document type "%s" should be included: %s', (type, expected)=>{
+            const doc = {
+                _id: '123',
+                _rev: 'v1',
+                _type: type
+            };
+            expect(shouldIncludeDocument(doc)).toBe(expected);
+        });
+    });
+});
+
+//# sourceMappingURL=validateDocuments.test.js.map

package/dist/util/validation/ __tests__/validateDocuments.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/validation/ __tests__/validateDocuments.test.ts"],"sourcesContent":["import {type SanityDocument} from '@sanity/client'\nimport {describe, expect, test} from 'vitest'\n\nimport {\n  DOCUMENT_VALIDATION_TIMEOUT,\n  getReferenceIds,\n  isValidId,\n  levelValues,\n  MAX_VALIDATION_CONCURRENCY,\n  REFERENCE_INTEGRITY_BATCH_SIZE,\n  shouldIncludeDocument,\n} from '../validateDocumentsUtils'\n\ndescribe('validateDocumentsUtils', () => {\n  describe('constants', () => {\n    test('should have correct values', () => {\n      expect(DOCUMENT_VALIDATION_TIMEOUT).toBe(30_000)\n      expect(MAX_VALIDATION_CONCURRENCY).toBe(100)\n      expect(REFERENCE_INTEGRITY_BATCH_SIZE).toBe(100)\n      expect(levelValues).toEqual({error: 0, info: 2, warning: 1})\n    })\n  })\n\n  describe('getReferenceIds', () => {\n    test('should extract reference IDs from various document structures', () => {\n      const testCases = [\n        {\n          doc: {author: {_ref: 'author-123', _type: 'reference'}},\n          expected: ['author-123'],\n          name: 'simple reference',\n        },\n        {\n          doc: {\n            author: {_ref: 'author-123', _type: 'reference'},\n            editor: {_ref: 'editor-456', _type: 'reference'},\n          },\n          expected: ['author-123', 'editor-456'],\n          name: 'multiple references',\n        },\n        {\n          doc: {\n            authors: [\n              {_ref: 'author-1', _type: 'reference'},\n              {_ref: 'author-2', _type: 'reference'},\n            ],\n          },\n          expected: ['author-1', 'author-2'],\n          name: 'array of references',\n        },\n        {\n          doc: {\n            content: {\n              sections: [{author: {_ref: 'nested-author', _type: 'reference'}}],\n            },\n          },\n          expected: ['nested-author'],\n          name: 'nested references',\n        },\n        {\n          doc: {\n            author: {_ref: 'same-id', _type: 'reference'},\n            editor: {_ref: 'same-id', _type: 'reference'},\n          },\n          expected: ['same-id'],\n          name: 'duplicate references',\n        },\n        {\n          doc: {content: 'Some content', title: 'Test'},\n          expected: [],\n          name: 'no references',\n        },\n      ]\n\n      for (const {doc, expected, name} of testCases) {\n        const ids = getReferenceIds(doc)\n        expect(ids.size, `Failed for: ${name}`).toBe(expected.length)\n        for (const id of expected) {\n          expect(ids.has(id), `Missing ID ${id} for: ${name}`).toBe(true)\n        }\n      }\n    })\n\n    test.each([\n      ['empty object', {}],\n      ['empty array', []],\n      ['null', null],\n      ['undefined', undefined],\n      ['string', 'string'],\n      ['number', 123],\n      ['boolean', true],\n    ])('should return empty set for %s', (_, value) => {\n      expect(getReferenceIds(value).size).toBe(0)\n    })\n  })\n\n  describe('isValidId', () => {\n    test.each([\n      ['abc123', true],\n      ['ABC123', true],\n      ['doc-123', true],\n      ['doc_123', true],\n      ['doc.123', true],\n      ['doc_123-456.789', true],\n      ['a', true],\n      ['-invalid', false],\n      ['', false],\n      [123, false],\n      [null, false],\n      [undefined, false],\n      [{}, false],\n      [[], false],\n    ])('isValidId(%s) should return %s', (id, expected) => {\n      expect(isValidId(id)).toBe(expected)\n    })\n  })\n\n  describe('shouldIncludeDocument', () => {\n    test.each([\n      ['article', true],\n      ['myCustomType', true],\n      ['my-custom_type', true],\n      ['systemConfig', true],\n      ['sanityConfig', true],\n      ['insanity', true],\n      ['system.settings', false],\n      ['system.config', false],\n      ['system.user', false],\n      ['sanity.imageAsset', false],\n      ['sanity.fileAsset', false],\n      ['sanity.dashboard', false],\n    ])('document type \"%s\" should be included: %s', (type, expected) => {\n      const doc = {_id: '123', _rev: 'v1', _type: type} as SanityDocument\n      expect(shouldIncludeDocument(doc)).toBe(expected)\n    })\n  })\n})\n"],"names":["describe","expect","test","DOCUMENT_VALIDATION_TIMEOUT","getReferenceIds","isValidId","levelValues","MAX_VALIDATION_CONCURRENCY","REFERENCE_INTEGRITY_BATCH_SIZE","shouldIncludeDocument","toBe","toEqual","error","info","warning","testCases","doc","author","_ref","_type","expected","name","editor","authors","content","sections","title","ids","size","length","id","has","each","undefined","_","value","type","_id","_rev"],"mappings":"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"}

package/dist/util/validation/validateDocumentsUtils.d.ts

@@ -0,0 +1,12 @@
+import { type SanityDocument } from '@sanity/client';
+export declare const DOCUMENT_VALIDATION_TIMEOUT = 30000;
+export declare const MAX_VALIDATION_CONCURRENCY = 100;
+export declare const REFERENCE_INTEGRITY_BATCH_SIZE = 100;
+export declare const levelValues: {
+    readonly error: 0;
+    readonly info: 2;
+    readonly warning: 1;
+};
+export declare const getReferenceIds: (value: unknown) => Set<string>;
+export declare const isValidId: (id: unknown) => boolean;
+export declare const shouldIncludeDocument: (document: SanityDocument) => boolean;

package/dist/util/validation/validateDocumentsUtils.js

@@ -0,0 +1,33 @@
+import { isReference } from '@sanity/types';
+export const DOCUMENT_VALIDATION_TIMEOUT = 30_000;
+export const MAX_VALIDATION_CONCURRENCY = 100;
+export const REFERENCE_INTEGRITY_BATCH_SIZE = 100;
+export const levelValues = {
+    error: 0,
+    info: 2,
+    warning: 1
+};
+export const getReferenceIds = (value)=>{
+    const ids = new Set();
+    function traverse(node) {
+        if (isReference(node)) {
+            ids.add(node._ref);
+            return;
+        }
+        if (typeof node === 'object' && node) {
+            // Note: this works for arrays too
+            for (const item of Object.values(node))traverse(item);
+        }
+    }
+    traverse(value);
+    return ids;
+};
+const idRegex = /^[^-][A-Z0-9._-]*$/i;
+// during testing, the `doc` endpoint 502'ed if given an invalid ID
+export const isValidId = (id)=>typeof id === 'string' && idRegex.test(id);
+export const shouldIncludeDocument = (document)=>{
+    // Filter out system documents and sanity documents
+    return !document._type.startsWith('system.') && !document._type.startsWith('sanity.');
+};
+
+//# sourceMappingURL=validateDocumentsUtils.js.map

package/dist/util/validation/validateDocumentsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/validation/validateDocumentsUtils.ts"],"sourcesContent":["import {type SanityDocument} from '@sanity/client'\nimport {isReference} from '@sanity/types'\n\nexport const DOCUMENT_VALIDATION_TIMEOUT = 30_000\nexport const MAX_VALIDATION_CONCURRENCY = 100\nexport const REFERENCE_INTEGRITY_BATCH_SIZE = 100\n\nexport const levelValues = {error: 0, info: 2, warning: 1} as const\n\nexport const getReferenceIds = (value: unknown) => {\n  const ids = new Set<string>()\n\n  function traverse(node: unknown) {\n    if (isReference(node)) {\n      ids.add(node._ref)\n      return\n    }\n\n    if (typeof node === 'object' && node) {\n      // Note: this works for arrays too\n      for (const item of Object.values(node)) traverse(item)\n    }\n  }\n\n  traverse(value)\n\n  return ids\n}\n\nconst idRegex = /^[^-][A-Z0-9._-]*$/i\n\n// during testing, the `doc` endpoint 502'ed if given an invalid ID\nexport const isValidId = (id: unknown) => typeof id === 'string' && idRegex.test(id)\nexport const shouldIncludeDocument = (document: SanityDocument) => {\n  // Filter out system documents and sanity documents\n  return !document._type.startsWith('system.') && !document._type.startsWith('sanity.')\n}\n"],"names":["isReference","DOCUMENT_VALIDATION_TIMEOUT","MAX_VALIDATION_CONCURRENCY","REFERENCE_INTEGRITY_BATCH_SIZE","levelValues","error","info","warning","getReferenceIds","value","ids","Set","traverse","node","add","_ref","item","Object","values","idRegex","isValidId","id","test","shouldIncludeDocument","document","_type","startsWith"],"mappings":"AACA,SAAQA,WAAW,QAAO,gBAAe;AAEzC,OAAO,MAAMC,8BAA8B,OAAM;AACjD,OAAO,MAAMC,6BAA6B,IAAG;AAC7C,OAAO,MAAMC,iCAAiC,IAAG;AAEjD,OAAO,MAAMC,cAAc;IAACC,OAAO;IAAGC,MAAM;IAAGC,SAAS;AAAC,EAAU;AAEnE,OAAO,MAAMC,kBAAkB,CAACC;IAC9B,MAAMC,MAAM,IAAIC;IAEhB,SAASC,SAASC,IAAa;QAC7B,IAAIb,YAAYa,OAAO;YACrBH,IAAII,GAAG,CAACD,KAAKE,IAAI;YACjB;QACF;QAEA,IAAI,OAAOF,SAAS,YAAYA,MAAM;YACpC,kCAAkC;YAClC,KAAK,MAAMG,QAAQC,OAAOC,MAAM,CAACL,MAAOD,SAASI;QACnD;IACF;IAEAJ,SAASH;IAET,OAAOC;AACT,EAAC;AAED,MAAMS,UAAU;AAEhB,mEAAmE;AACnE,OAAO,MAAMC,YAAY,CAACC,KAAgB,OAAOA,OAAO,YAAYF,QAAQG,IAAI,CAACD,IAAG;AACpF,OAAO,MAAME,wBAAwB,CAACC;IACpC,mDAAmD;IACnD,OAAO,CAACA,SAASC,KAAK,CAACC,UAAU,CAAC,cAAc,CAACF,SAASC,KAAK,CAACC,UAAU,CAAC;AAC7E,EAAC"}

package/dist/util/warnAboutMissingAppId.d.ts

@@ -0,0 +1,7 @@
+import { type Output } from '@sanity/cli-core';
+export declare function warnAboutMissingAppId({ appType, cliConfigPath, output, projectId, }: {
+    appType: 'app' | 'studio';
+    cliConfigPath?: string;
+    output: Output;
+    projectId?: string;
+}): void;

package/dist/util/warnAboutMissingAppId.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+import { chalk, logSymbols } from '@sanity/cli-core/ux';
+const baseUrl = process.env.SANITY_INTERNAL_ENV === 'staging' ? 'https://sanity.work' : 'https://www.sanity.io';
+export function warnAboutMissingAppId({ appType, cliConfigPath, output, projectId }) {
+    const manageUrl = `${baseUrl}/manage${projectId ? `/project/${projectId}/studios` : ''}`;
+    const cliConfigFile = cliConfigPath ? path.basename(cliConfigPath) : 'sanity.cli.ts/.js';
+    output.warn(`${logSymbols.warning} No ${chalk.bold('appId')} configured. This ${appType} will auto-update to the ${chalk.green.bold('latest')} channel. To enable fine grained version selection, head over to ${chalk.cyan(manageUrl)} and add the appId to the ${chalk.bold('deployment')} section in ${chalk.bold(cliConfigFile)}.
+        `);
+}
+
+//# sourceMappingURL=warnAboutMissingAppId.js.map

package/dist/util/warnAboutMissingAppId.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/warnAboutMissingAppId.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {type Output} from '@sanity/cli-core'\nimport {chalk, logSymbols} from '@sanity/cli-core/ux'\n\nconst baseUrl =\n  process.env.SANITY_INTERNAL_ENV === 'staging' ? 'https://sanity.work' : 'https://www.sanity.io'\n\nexport function warnAboutMissingAppId({\n  appType,\n  cliConfigPath,\n  output,\n  projectId,\n}: {\n  appType: 'app' | 'studio'\n  cliConfigPath?: string\n  output: Output\n  projectId?: string\n}) {\n  const manageUrl = `${baseUrl}/manage${projectId ? `/project/${projectId}/studios` : ''}`\n  const cliConfigFile = cliConfigPath ? path.basename(cliConfigPath) : 'sanity.cli.ts/.js'\n  output.warn(\n    `${logSymbols.warning} No ${chalk.bold('appId')} configured. This ${appType} will auto-update to the ${chalk.green.bold('latest')} channel. To enable fine grained version selection, head over to ${chalk.cyan(manageUrl)} and add the appId to the ${chalk.bold('deployment')} section in ${chalk.bold(cliConfigFile)}.\n        `,\n  )\n}\n"],"names":["path","chalk","logSymbols","baseUrl","process","env","SANITY_INTERNAL_ENV","warnAboutMissingAppId","appType","cliConfigPath","output","projectId","manageUrl","cliConfigFile","basename","warn","warning","bold","green","cyan"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAG5B,SAAQC,KAAK,EAAEC,UAAU,QAAO,sBAAqB;AAErD,MAAMC,UACJC,QAAQC,GAAG,CAACC,mBAAmB,KAAK,YAAY,wBAAwB;AAE1E,OAAO,SAASC,sBAAsB,EACpCC,OAAO,EACPC,aAAa,EACbC,MAAM,EACNC,SAAS,EAMV;IACC,MAAMC,YAAY,GAAGT,QAAQ,OAAO,EAAEQ,YAAY,CAAC,SAAS,EAAEA,UAAU,QAAQ,CAAC,GAAG,IAAI;IACxF,MAAME,gBAAgBJ,gBAAgBT,KAAKc,QAAQ,CAACL,iBAAiB;IACrEC,OAAOK,IAAI,CACT,GAAGb,WAAWc,OAAO,CAAC,IAAI,EAAEf,MAAMgB,IAAI,CAAC,SAAS,kBAAkB,EAAET,QAAQ,yBAAyB,EAAEP,MAAMiB,KAAK,CAACD,IAAI,CAAC,UAAU,iEAAiE,EAAEhB,MAAMkB,IAAI,CAACP,WAAW,0BAA0B,EAAEX,MAAMgB,IAAI,CAAC,cAAc,YAAY,EAAEhB,MAAMgB,IAAI,CAACJ,eAAe;QACpT,CAAC;AAET"}

package/dist/util/workerChannels.d.ts

@@ -0,0 +1,59 @@
+import { type MessagePort, type Worker } from 'node:worker_threads';
+type StreamReporter<TPayload = unknown> = {
+    emit: (payload: TPayload) => void;
+    end: () => void;
+};
+type EventReporter<TPayload = unknown> = (payload: TPayload) => void;
+type EventReceiver<TPayload = unknown> = () => Promise<TPayload>;
+type StreamReceiver<TPayload = unknown> = () => AsyncIterable<TPayload>;
+type EventKeys<TWorkerChannel extends WorkerChannel> = {
+    [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelEvent<any> ? K : never;
+}[keyof TWorkerChannel];
+type StreamKeys<TWorkerChannel extends WorkerChannel> = {
+    [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelStream<any> ? K : never;
+}[keyof TWorkerChannel];
+/**
+ * Represents the definition of a "worker channel" to report progress from the
+ * worker to the parent. Worker channels can define named events or streams and
+ * the worker will report events and streams while the parent will await them.
+ * This allows the control flow of the parent to follow the control flow of the
+ * worker 1-to-1.
+ */
+export type WorkerChannel<TWorkerChannel extends Record<string, WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>> = Record<string, WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>>> = TWorkerChannel;
+export type WorkerChannelEvent<TPayload = void> = {
+    payload: TPayload;
+    type: 'event';
+};
+export type WorkerChannelStream<TPayload = void> = {
+    payload: TPayload;
+    type: 'stream';
+};
+interface WorkerChannelReporter<TWorkerChannel extends WorkerChannel> {
+    event: {
+        [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload> ? EventReporter<TPayload> : void;
+    };
+    stream: {
+        [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload> ? StreamReporter<TPayload> : void;
+    };
+}
+export interface WorkerChannelReceiver<TWorkerChannel extends WorkerChannel> {
+    dispose: () => Promise<number>;
+    event: {
+        [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload> ? EventReceiver<TPayload> : void;
+    };
+    stream: {
+        [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload> ? StreamReceiver<TPayload> : void;
+    };
+}
+/**
+ * Creates a "worker channel receiver" that subscribes to incoming messages
+ * from the given worker and returns promises for worker channel events and
+ * async iterators for worker channel streams.
+ */
+export declare function createReceiver<TWorkerChannel extends WorkerChannel>(worker: Worker): WorkerChannelReceiver<TWorkerChannel>;
+/**
+ * Creates a "worker channel reporter" that sends messages to the given
+ * `parentPort` to be received by a worker channel receiver.
+ */
+export declare function createReporter<TWorkerChannel extends WorkerChannel>(parentPort: MessagePort | null): WorkerChannelReporter<TWorkerChannel>;
+export {};

package/dist/util/workerChannels.js

@@ -0,0 +1,172 @@
+/**
+ * A simple queue that has two primary methods: `push(message)` and
+ * `await next()`. This message queue is used by the "receiver" of the worker
+ * channel and this class handles buffering incoming messages if the worker is
+ * producing faster than the parent as well as returning a promise if there is
+ * no message yet in the queue when the parent awaits `next()`.
+ */ class MessageQueue {
+    queue = [];
+    resolver = null;
+    end() {
+        if (this.resolver) {
+            this.resolver({
+                done: true,
+                value: undefined
+            });
+        }
+    }
+    next() {
+        if (this.queue.length > 0) {
+            return Promise.resolve({
+                done: false,
+                value: this.queue.shift()
+            });
+        }
+        return new Promise((resolve)=>this.resolver = resolve);
+    }
+    push(message) {
+        if (this.resolver) {
+            this.resolver({
+                done: false,
+                value: message
+            });
+            this.resolver = null;
+        } else {
+            this.queue.push(message);
+        }
+    }
+}
+function isWorkerChannelMessage(message) {
+    if (typeof message !== 'object') return false;
+    if (!message) return false;
+    if (!('type' in message)) return false;
+    if (typeof message.type !== 'string') return false;
+    const types = [
+        'event',
+        'emission',
+        'end'
+    ];
+    return types.includes(message.type);
+}
+/**
+ * Creates a "worker channel receiver" that subscribes to incoming messages
+ * from the given worker and returns promises for worker channel events and
+ * async iterators for worker channel streams.
+ */ export function createReceiver(worker) {
+    const _events = new Map();
+    const _streams = new Map();
+    const errors = new MessageQueue();
+    const eventQueue = (name)=>{
+        const queue = _events.get(name) ?? new MessageQueue();
+        if (!_events.has(name)) _events.set(name, queue);
+        return queue;
+    };
+    const streamQueue = (name)=>{
+        const queue = _streams.get(name) ?? new MessageQueue();
+        if (!_streams.has(name)) _streams.set(name, queue);
+        return queue;
+    };
+    const handleMessage = (message)=>{
+        if (!isWorkerChannelMessage(message)) return;
+        if (message.type === 'event') eventQueue(message.name).push(message);
+        if (message.type === 'emission') streamQueue(message.name).push(message);
+        if (message.type === 'end') streamQueue(message.name).end();
+    };
+    const handleError = (error)=>{
+        errors.push({
+            error,
+            type: 'error'
+        });
+    };
+    worker.addListener('message', handleMessage);
+    worker.addListener('error', handleError);
+    return {
+        dispose: ()=>{
+            worker.removeListener('message', handleMessage);
+            worker.removeListener('error', handleError);
+            return worker.terminate();
+        },
+        event: new Proxy({}, {
+            get: (target, name)=>{
+                if (typeof name !== 'string') return target[name];
+                const eventReceiver = async ()=>{
+                    const { value } = await Promise.race([
+                        eventQueue(name).next(),
+                        errors.next()
+                    ]);
+                    if (value.type === 'error') throw value.error;
+                    return value.payload;
+                };
+                return eventReceiver;
+            }
+        }),
+        stream: new Proxy({}, {
+            get: (target, prop)=>{
+                if (typeof prop !== 'string') return target[prop];
+                const name = prop // alias for better typescript narrowing
+                ;
+                async function* streamReceiver() {
+                    while(true){
+                        const { done, value } = await Promise.race([
+                            streamQueue(name).next(),
+                            errors.next()
+                        ]);
+                        if (done) return;
+                        if (value.type === 'error') throw value.error;
+                        yield value.payload;
+                    }
+                }
+                return streamReceiver;
+            }
+        })
+    };
+}
+/**
+ * Creates a "worker channel reporter" that sends messages to the given
+ * `parentPort` to be received by a worker channel receiver.
+ */ export function createReporter(parentPort) {
+    if (!parentPort) {
+        throw new Error('parentPart was falsy');
+    }
+    return {
+        event: new Proxy({}, {
+            get: (target, name)=>{
+                if (typeof name !== 'string') return target[name];
+                const eventReporter = (payload)=>{
+                    const message = {
+                        name,
+                        payload,
+                        type: 'event'
+                    };
+                    parentPort.postMessage(message);
+                };
+                return eventReporter;
+            }
+        }),
+        stream: new Proxy({}, {
+            get: (target, name)=>{
+                if (typeof name !== 'string') return target[name];
+                const streamReporter = {
+                    emit: (payload)=>{
+                        const message = {
+                            name,
+                            payload,
+                            type: 'emission'
+                        };
+                        parentPort.postMessage(message);
+                    },
+                    end: ()=>{
+                        const message = {
+                            name,
+                            type: 'end'
+                        };
+                        parentPort.postMessage(message);
+                    }
+                };
+                return streamReporter;
+            }
+        })
+    };
+}
+
+//# sourceMappingURL=workerChannels.js.map

package/dist/util/workerChannels.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/workerChannels.ts"],"sourcesContent":["import {type MessagePort, type Worker} from 'node:worker_threads'\n\ntype StreamReporter<TPayload = unknown> = {emit: (payload: TPayload) => void; end: () => void}\ntype EventReporter<TPayload = unknown> = (payload: TPayload) => void\ntype EventReceiver<TPayload = unknown> = () => Promise<TPayload>\ntype StreamReceiver<TPayload = unknown> = () => AsyncIterable<TPayload>\n\ntype EventKeys<TWorkerChannel extends WorkerChannel> = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelEvent<any> ? K : never\n}[keyof TWorkerChannel]\ntype StreamKeys<TWorkerChannel extends WorkerChannel> = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelStream<any> ? K : never\n}[keyof TWorkerChannel]\n\ntype EventMessage<TPayload = unknown> = {name: string; payload: TPayload; type: 'event'}\ntype StreamEmissionMessage<TPayload = unknown> = {name: string; payload: TPayload; type: 'emission'}\ntype StreamEndMessage = {name: string; type: 'end'}\ntype WorkerChannelMessage = EventMessage | StreamEmissionMessage | StreamEndMessage\n\n/**\n * Represents the definition of a \"worker channel\" to report progress from the\n * worker to the parent. Worker channels can define named events or streams and\n * the worker will report events and streams while the parent will await them.\n * This allows the control flow of the parent to follow the control flow of the\n * worker 1-to-1.\n */\nexport type WorkerChannel<\n  TWorkerChannel extends Record<\n    string,\n    WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>\n  > = Record<string, WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>>,\n> = TWorkerChannel\n\nexport type WorkerChannelEvent<TPayload = void> = {payload: TPayload; type: 'event'}\nexport type WorkerChannelStream<TPayload = void> = {\n  payload: TPayload\n  type: 'stream'\n}\n\ninterface WorkerChannelReporter<TWorkerChannel extends WorkerChannel> {\n  event: {\n    [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload>\n      ? EventReporter<TPayload>\n      : void\n  }\n  stream: {\n    [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload>\n      ? StreamReporter<TPayload>\n      : void\n  }\n}\n\nexport interface WorkerChannelReceiver<TWorkerChannel extends WorkerChannel> {\n  // TODO: good candidate for [Symbol.asyncDispose] when our tooling better supports it\n  dispose: () => Promise<number>\n  event: {\n    [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload>\n      ? EventReceiver<TPayload>\n      : void\n  }\n  stream: {\n    [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload>\n      ? StreamReceiver<TPayload>\n      : void\n  }\n}\n\n/**\n * A simple queue that has two primary methods: `push(message)` and\n * `await next()`. This message queue is used by the \"receiver\" of the worker\n * channel and this class handles buffering incoming messages if the worker is\n * producing faster than the parent as well as returning a promise if there is\n * no message yet in the queue when the parent awaits `next()`.\n */\nclass MessageQueue<T> {\n  queue: T[] = []\n  resolver: ((result: IteratorResult<T>) => void) | null = null\n\n  end() {\n    if (this.resolver) {\n      this.resolver({done: true, value: undefined})\n    }\n  }\n\n  next(): Promise<IteratorResult<T>> {\n    if (this.queue.length > 0) {\n      return Promise.resolve({done: false, value: this.queue.shift()!})\n    }\n\n    return new Promise((resolve) => (this.resolver = resolve))\n  }\n\n  push(message: T) {\n    if (this.resolver) {\n      this.resolver({done: false, value: message})\n      this.resolver = null\n    } else {\n      this.queue.push(message)\n    }\n  }\n}\n\nfunction isWorkerChannelMessage(message: unknown): message is WorkerChannelMessage {\n  if (typeof message !== 'object') return false\n  if (!message) return false\n  if (!('type' in message)) return false\n  if (typeof message.type !== 'string') return false\n  const types: string[] = ['event', 'emission', 'end'] satisfies WorkerChannelMessage['type'][]\n  return types.includes(message.type)\n}\n\n/**\n * Creates a \"worker channel receiver\" that subscribes to incoming messages\n * from the given worker and returns promises for worker channel events and\n * async iterators for worker channel streams.\n */\nexport function createReceiver<TWorkerChannel extends WorkerChannel>(\n  worker: Worker,\n): WorkerChannelReceiver<TWorkerChannel> {\n  const _events = new Map<string, MessageQueue<EventMessage>>()\n  const _streams = new Map<string, MessageQueue<StreamEmissionMessage>>()\n  const errors = new MessageQueue<{error: unknown; type: 'error'}>()\n\n  const eventQueue = (name: string) => {\n    const queue = _events.get(name) ?? new MessageQueue()\n    if (!_events.has(name)) _events.set(name, queue)\n    return queue\n  }\n\n  const streamQueue = (name: string) => {\n    const queue = _streams.get(name) ?? new MessageQueue()\n    if (!_streams.has(name)) _streams.set(name, queue)\n    return queue\n  }\n\n  const handleMessage = (message: unknown) => {\n    if (!isWorkerChannelMessage(message)) return\n    if (message.type === 'event') eventQueue(message.name).push(message)\n    if (message.type === 'emission') streamQueue(message.name).push(message)\n    if (message.type === 'end') streamQueue(message.name).end()\n  }\n\n  const handleError = (error: unknown) => {\n    errors.push({error, type: 'error'})\n  }\n\n  worker.addListener('message', handleMessage)\n  worker.addListener('error', handleError)\n\n  return {\n    dispose: () => {\n      worker.removeListener('message', handleMessage)\n      worker.removeListener('error', handleError)\n      return worker.terminate()\n    },\n    event: new Proxy({} as WorkerChannelReceiver<TWorkerChannel>['event'], {\n      get: (target, name) => {\n        if (typeof name !== 'string') return target[name as keyof typeof target]\n\n        const eventReceiver: EventReceiver = async () => {\n          const {value} = await Promise.race([eventQueue(name).next(), errors.next()])\n          if (value.type === 'error') throw value.error\n          return value.payload\n        }\n\n        return eventReceiver\n      },\n    }),\n    stream: new Proxy({} as WorkerChannelReceiver<TWorkerChannel>['stream'], {\n      get: (target, prop) => {\n        if (typeof prop !== 'string') return target[prop as keyof typeof target]\n        const name = prop // alias for better typescript narrowing\n\n        async function* streamReceiver() {\n          while (true) {\n            const {done, value} = await Promise.race([streamQueue(name).next(), errors.next()])\n            if (done) return\n            if (value.type === 'error') throw value.error\n            yield value.payload\n          }\n        }\n\n        return streamReceiver satisfies StreamReceiver\n      },\n    }),\n  }\n}\n\n/**\n * Creates a \"worker channel reporter\" that sends messages to the given\n * `parentPort` to be received by a worker channel receiver.\n */\nexport function createReporter<TWorkerChannel extends WorkerChannel>(\n  parentPort: MessagePort | null,\n): WorkerChannelReporter<TWorkerChannel> {\n  if (!parentPort) {\n    throw new Error('parentPart was falsy')\n  }\n\n  return {\n    event: new Proxy({} as WorkerChannelReporter<TWorkerChannel>['event'], {\n      get: (target, name) => {\n        if (typeof name !== 'string') return target[name as keyof typeof target]\n\n        const eventReporter: EventReporter = (payload) => {\n          const message: EventMessage = {name, payload, type: 'event'}\n          parentPort.postMessage(message)\n        }\n\n        return eventReporter\n      },\n    }),\n    stream: new Proxy({} as WorkerChannelReporter<TWorkerChannel>['stream'], {\n      get: (target, name) => {\n        if (typeof name !== 'string') return target[name as keyof typeof target]\n\n        const streamReporter: StreamReporter = {\n          emit: (payload) => {\n            const message: StreamEmissionMessage = {name, payload, type: 'emission'}\n            parentPort.postMessage(message)\n          },\n          end: () => {\n            const message: StreamEndMessage = {name, type: 'end'}\n            parentPort.postMessage(message)\n          },\n        }\n\n        return streamReporter\n      },\n    }),\n  }\n}\n"],"names":["MessageQueue","queue","resolver","end","done","value","undefined","next","length","Promise","resolve","shift","push","message","isWorkerChannelMessage","type","types","includes","createReceiver","worker","_events","Map","_streams","errors","eventQueue","name","get","has","set","streamQueue","handleMessage","handleError","error","addListener","dispose","removeListener","terminate","event","Proxy","target","eventReceiver","race","payload","stream","prop","streamReceiver","createReporter","parentPort","Error","eventReporter","postMessage","streamReporter","emit"],"mappings":"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"}