@sanity/cli 3.86.2-experimental.0 → 3.87.0

package/src/workers/typegenGenerate.ts

@@ -2,90 +2,228 @@ import {isMainThread, parentPort, workerData as _workerData} from 'node:worker_t
 
 import {
   findQueriesInPath,
-  type GeneratedQueries,
-  type GeneratedSchema,
-  type GeneratedTypemap,
-  generateTypes,
   getResolver,
   readSchema,
   registerBabel,
+  safeParseQuery,
+  TypeGenerator,
 } from '@sanity/codegen'
 import createDebug from 'debug'
-import {type SchemaType} from 'groq-js'
-
-import {
-  createReporter,
-  type WorkerChannel,
-  type WorkerChannelEvent,
-  type WorkerChannelStream,
-} from '../util/workerChannel'
+import {typeEvaluate, type TypeNode} from 'groq-js'
 
 const $info = createDebug('sanity:codegen:generate:info')
+const $warn = createDebug('sanity:codegen:generate:warn')
 
 export interface TypegenGenerateTypesWorkerData {
   workDir: string
-  schemas: {
-    projectId: string | 'default'
-    dataset: string | 'default'
-    schemaPath: string
-  }[]
+  workspaceName?: string
+  schemaPath: string
   searchPath: string | string[]
-  overloadClientMethods: boolean
-  augmentGroqModule: boolean
+  overloadClientMethods?: boolean
 }
 
-/** @internal */
-export type TypegenWorkerChannel = WorkerChannel<{
-  schema: WorkerChannelEvent<GeneratedSchema>
-  queries: WorkerChannelStream<GeneratedQueries>
-  typemap: WorkerChannelEvent<GeneratedTypemap>
-}>
+export type TypegenGenerateTypesWorkerMessage =
+  | {
+      type: 'error'
+      error: Error
+      fatal: boolean
+      query?: string
+      filename?: string
+    }
+  | {
+      type: 'types'
+      filename: string
+      types: {
+        queryName: string
+        query: string
+        type: string
+        unknownTypeNodesGenerated: number
+        typeNodesGenerated: number
+        emptyUnionTypeNodesGenerated: number
+      }[]
+    }
+  | {
+      type: 'schema'
+      filename: string
+      schema: string
+      length: number
+    }
+  | {
+      type: 'typemap'
+      typeMap: string
+    }
+  | {
+      type: 'complete'
+    }
 
 if (isMainThread || !parentPort) {
   throw new Error('This module must be run as a worker thread')
 }
 
-const report = createReporter<TypegenWorkerChannel>(parentPort)
 const opts = _workerData as TypegenGenerateTypesWorkerData
 
+registerBabel()
+
 async function main() {
-  const schemas: {
-    schema: SchemaType
-    projectId: string | 'default'
-    dataset: string | 'default'
-    filename: string
-  }[] = []
-
-  for (const schemaConfig of opts.schemas) {
-    $info(`Reading schema from ${schemaConfig.schemaPath}...`)
-    const schema = await readSchema(schemaConfig.schemaPath)
-    schemas.push({
-      schema,
-      projectId: schemaConfig.projectId,
-      dataset: schemaConfig.dataset,
-      filename: schemaConfig.schemaPath,
-    })
-  }
-  $info(`Read ${schemas.length} schema definition${schemas.length === 1 ? '' : 's'} successfully.`)
+  const schema = await readSchema(opts.schemaPath)
 
+  const typeGenerator = new TypeGenerator(schema)
+  const schemaTypes = [typeGenerator.generateSchemaTypes(), TypeGenerator.generateKnownTypes()]
+    .join('\n')
+    .trim()
   const resolver = getResolver()
 
-  const result = generateTypes({
-    schemas,
-    queriesByFile: findQueriesInPath({path: opts.searchPath, resolver}),
-    augmentGroqModule: opts.augmentGroqModule,
-    overloadClientMethods: opts.overloadClientMethods,
+  parentPort?.postMessage({
+    type: 'schema',
+    schema: `${schemaTypes.trim()}\n`,
+    filename: 'schema.json',
+    length: schema.length,
+  } satisfies TypegenGenerateTypesWorkerMessage)
+
+  const queries = findQueriesInPath({
+    path: opts.searchPath,
+    resolver,
   })
 
-  report.event.schema(await result.generatedSchema())
+  const allQueries = []
+
+  for await (const result of queries) {
+    if (result.type === 'error') {
+      parentPort?.postMessage({
+        type: 'error',
+        error: result.error,
+        fatal: false,
+        filename: result.filename,
+      } satisfies TypegenGenerateTypesWorkerMessage)
+      continue
+    }
+    $info(`Processing ${result.queries.length} queries in "${result.filename}"...`)
+
+    const fileQueryTypes: {
+      queryName: string
+      query: string
+      type: string
+      typeName: string
+      typeNode: TypeNode
+      unknownTypeNodesGenerated: number
+      typeNodesGenerated: number
+      emptyUnionTypeNodesGenerated: number
+    }[] = []
+    for (const {name: queryName, result: query} of result.queries) {
+      try {
+        const ast = safeParseQuery(query)
+        const queryTypes = typeEvaluate(ast, schema)
+
+        const typeName = `${queryName}Result`
+        const type = typeGenerator.generateTypeNodeTypes(typeName, queryTypes)
+
+        const queryTypeStats = walkAndCountQueryTypeNodeStats(queryTypes)
+        fileQueryTypes.push({
+          queryName,
+          query,
+          typeName,
+          typeNode: queryTypes,
+          type: `${type.trim()}\n`,
+          unknownTypeNodesGenerated: queryTypeStats.unknownTypes,
+          typeNodesGenerated: queryTypeStats.allTypes,
+          emptyUnionTypeNodesGenerated: queryTypeStats.emptyUnions,
+        })
+      } catch (err) {
+        parentPort?.postMessage({
+          type: 'error',
+          error: new Error(
+            `Error generating types for query "${queryName}" in "${result.filename}": ${err.message}`,
+            {cause: err},
+          ),
+          fatal: false,
+          query,
+        } satisfies TypegenGenerateTypesWorkerMessage)
+      }
+    }
 
-  for await (const {filename, results} of result.generatedQueries()) {
-    report.stream.queries.emit({filename, results})
+    if (fileQueryTypes.length > 0) {
+      $info(`Generated types for ${fileQueryTypes.length} queries in "${result.filename}"\n`)
+      parentPort?.postMessage({
+        type: 'types',
+        types: fileQueryTypes,
+        filename: result.filename,
+      } satisfies TypegenGenerateTypesWorkerMessage)
+    }
+
+    if (fileQueryTypes.length > 0) {
+      allQueries.push(...fileQueryTypes)
+    }
+  }
+
+  if (opts.overloadClientMethods && allQueries.length > 0) {
+    const typeMap = `${typeGenerator.generateQueryMap(allQueries).trim()}\n`
+    parentPort?.postMessage({
+      type: 'typemap',
+      typeMap,
+    } satisfies TypegenGenerateTypesWorkerMessage)
   }
-  report.stream.queries.end()
 
-  report.event.typemap(await result.generatedTypemap())
+  parentPort?.postMessage({
+    type: 'complete',
+  } satisfies TypegenGenerateTypesWorkerMessage)
+}
+
+function walkAndCountQueryTypeNodeStats(typeNode: TypeNode): {
+  allTypes: number
+  unknownTypes: number
+  emptyUnions: number
+} {
+  switch (typeNode.type) {
+    case 'unknown': {
+      return {allTypes: 1, unknownTypes: 1, emptyUnions: 0}
+    }
+    case 'array': {
+      const acc = walkAndCountQueryTypeNodeStats(typeNode.of)
+      acc.allTypes += 1 // count the array type itself
+      return acc
+    }
+    case 'object': {
+      // if the rest is unknown, we count it as one unknown type
+      if (typeNode.rest && typeNode.rest.type === 'unknown') {
+        return {allTypes: 2, unknownTypes: 1, emptyUnions: 0} // count the object type itself as well
+      }
+
+      const restStats = typeNode.rest
+        ? walkAndCountQueryTypeNodeStats(typeNode.rest)
+        : {allTypes: 1, unknownTypes: 0, emptyUnions: 0} // count the object type itself
+
+      return Object.values(typeNode.attributes).reduce((acc, attribute) => {
+        const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(
+          attribute.value,
+        )
+        return {
+          allTypes: acc.allTypes + allTypes,
+          unknownTypes: acc.unknownTypes + unknownTypes,
+          emptyUnions: acc.emptyUnions + emptyUnions,
+        }
+      }, restStats)
+    }
+    case 'union': {
+      if (typeNode.of.length === 0) {
+        return {allTypes: 1, unknownTypes: 0, emptyUnions: 1}
+      }
+
+      return typeNode.of.reduce(
+        (acc, type) => {
+          const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(type)
+          return {
+            allTypes: acc.allTypes + allTypes,
+            unknownTypes: acc.unknownTypes + unknownTypes,
+            emptyUnions: acc.emptyUnions + emptyUnions,
+          }
+        },
+        {allTypes: 1, unknownTypes: 0, emptyUnions: 0}, // count the union type itself
+      )
+    }
+    default: {
+      return {allTypes: 1, unknownTypes: 0, emptyUnions: 0}
+    }
+  }
 }
 
-registerBabel()
 main()

package/templates/app-sanity-ui/src/App.tsx

@@ -24,13 +24,13 @@ export function App() {
   }
 
   return (
-    <SanityApp config={sanityConfigs} fallback={<Loading />}>
-      <ThemeProvider theme={theme}>
+    <ThemeProvider theme={theme}>
+      <SanityApp config={sanityConfigs} fallback={<Loading />}>
         {/* add your own components here! */}
         <ExampleComponent />
-      </ThemeProvider>
-    </SanityApp>
-  )
+      </SanityApp>
+    </ThemeProvider>
+  );
 }
 
 export default App

package/lib/_chunks-cjs/workerChannel.js

@@ -1,84 +0,0 @@
-"use strict";
-class MessageQueue {
-  resolver = null;
-  queue = [];
-  ended = !1;
-  // Flag to indicate if end() was called
-  push(message) {
-    this.ended || (this.resolver ? (this.resolver({ value: message, done: !1 }), this.resolver = null) : this.queue.push(message));
-  }
-  next() {
-    return this.queue.length ? Promise.resolve({ value: this.queue.shift(), done: !1 }) : this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((resolve) => this.resolver = resolve);
-  }
-  end() {
-    this.resolver ? (this.resolver({ value: void 0, done: !0 }), this.resolver = null) : this.ended = !0;
-  }
-}
-function isWorkerChannelMessage(message) {
-  return typeof message != "object" || !message || !("type" in message) || typeof message.type != "string" ? !1 : ["event", "emission", "end"].includes(message.type);
-}
-function createReceiver(worker) {
-  const _events = /* @__PURE__ */ new Map(), _streams = /* @__PURE__ */ new Map(), errors = new MessageQueue(), eventQueue = (name) => {
-    const queue = _events.get(name) ?? new MessageQueue();
-    return _events.has(name) || _events.set(name, queue), queue;
-  }, streamQueue = (name) => {
-    const queue = _streams.get(name) ?? new MessageQueue();
-    return _streams.has(name) || _streams.set(name, queue), queue;
-  }, handleMessage = (message) => {
-    isWorkerChannelMessage(message) && (message.type === "event" && eventQueue(message.name).push(message), message.type === "emission" && streamQueue(message.name).push(message), message.type === "end" && streamQueue(message.name).end());
-  }, handleError = (error) => {
-    errors.push({ type: "error", error });
-  };
-  return worker.addListener("message", handleMessage), worker.addListener("error", handleError), {
-    event: new Proxy({}, {
-      get: (target, name) => typeof name != "string" ? target[name] : async () => {
-        const { value } = await Promise.race([eventQueue(name).next(), errors.next()]);
-        if (value.type === "error") throw value.error;
-        return value.payload;
-      }
-    }),
-    stream: new Proxy({}, {
-      get: (target, prop) => {
-        if (typeof prop != "string") return target[prop];
-        const name = prop;
-        async function* streamReceiver() {
-          for (; ; ) {
-            const { value, done } = await Promise.race([streamQueue(name).next(), errors.next()]);
-            if (done) return;
-            if (value.type === "error") throw value.error;
-            yield value.payload;
-          }
-        }
-        return streamReceiver;
-      }
-    }),
-    dispose: () => (worker.removeListener("message", handleMessage), worker.removeListener("error", handleError), worker.terminate())
-  };
-}
-function createReporter(parentPort) {
-  if (!parentPort)
-    throw new Error("parentPart was falsy");
-  return {
-    event: new Proxy({}, {
-      get: (target, name) => typeof name != "string" ? target[name] : (payload) => {
-        const message = { type: "event", name, payload };
-        parentPort.postMessage(message);
-      }
-    }),
-    stream: new Proxy({}, {
-      get: (target, name) => typeof name != "string" ? target[name] : {
-        emit: (payload) => {
-          const message = { type: "emission", name, payload };
-          parentPort.postMessage(message);
-        },
-        end: () => {
-          const message = { type: "end", name };
-          parentPort.postMessage(message);
-        }
-      }
-    })
-  };
-}
-exports.createReceiver = createReceiver;
-exports.createReporter = createReporter;
-//# sourceMappingURL=workerChannel.js.map

package/lib/_chunks-cjs/workerChannel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workerChannel.js","sources":["../../src/util/workerChannel.ts"],"sourcesContent":["// NOTE: this file was originally copied from\n// https://github.com/sanity-io/sanity/blob/4c4e03d407106dbda12f52cfd9511fbfe75a9696/packages/sanity/src/_internal/cli/util/workerChannels.ts\nimport {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  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelEvent<any> ? K : never\n}[keyof TWorkerChannel]\ntype StreamKeys<TWorkerChannel extends WorkerChannel> = {\n  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelStream<any> ? K : never\n}[keyof TWorkerChannel]\n\ntype EventMessage<TPayload = unknown> = {type: 'event'; name: string; payload: TPayload}\ntype StreamEmissionMessage<TPayload = unknown> = {type: 'emission'; name: string; payload: TPayload}\ntype StreamEndMessage = {type: 'end'; name: string}\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 *\n * @example\n *\n * ```ts\n * // Define the channel interface (shared between parent and worker)\n * type MyWorkerChannel = WorkerChannel<{\n *   compileStart: WorkerChannelEvent<void>\n *   compileProgress: WorkerChannelStream<{ file: string; progress: number }>\n *   compileEnd: WorkerChannelEvent<{ duration: number }>\n * }>;\n *\n * // --- In the worker file (e.g., worker.ts) ---\n * import { parentPort } from 'node:worker_threads';\n * import { createReporter } from './workerChannels';\n *\n * const report = createReporter<MyWorkerChannel>(parentPort);\n *\n * async function runCompilation() {\n *   report.event.compileStart(); // Signal start\n *\n *   const files = ['a.js', 'b.js', 'c.js'];\n *   for (const file of files) {\n *     // Simulate work and report progress\n *     await new Promise(resolve => setTimeout(resolve, 100));\n *     report.stream.compileProgress.emit({ file, progress: 100 });\n *   }\n *   report.stream.compileProgress.end(); // Signal end of progress stream\n *\n *   report.event.compileEnd({ duration: 300 }); // Signal end with result\n * }\n *\n * runCompilation();\n *\n * // --- In the parent file (e.g., main.ts) ---\n * import { Worker } from 'node:worker_threads';\n * import { createReceiver } from './workerChannels';\n *\n * const worker = new Worker('./worker.js');\n * const receiver = createReceiver<MyWorkerChannel>(worker);\n *\n * async function monitorCompilation() {\n *   console.log('Waiting for compilation to start...');\n *   await receiver.event.compileStart();\n *   console.log('Compilation started.');\n *\n *   console.log('Receiving progress:');\n *   for await (const progress of receiver.stream.compileProgress()) {\n *     console.log(`  - ${progress.file}: ${progress.progress}%`);\n *   }\n *\n *   console.log('Waiting for compilation to end...');\n *   const { duration } = await receiver.event.compileEnd();\n *   console.log(`Compilation finished in ${duration}ms.`);\n *\n *   await receiver.dispose(); // Clean up listeners and terminate worker\n * }\n *\n * monitorCompilation();\n * ```\n *\n * @internal\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\n/** @internal */\nexport type WorkerChannelEvent<TPayload = void> = {type: 'event'; payload: TPayload}\n/** @internal */\nexport type WorkerChannelStream<TPayload = void> = {type: 'stream'; payload: TPayload}\n\nexport interface 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  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  // TODO: good candidate for [Symbol.asyncDispose] when our tooling better supports it\n  dispose: () => Promise<number>\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  resolver: ((result: IteratorResult<T>) => void) | null = null\n  queue: T[] = []\n  private ended = false // Flag to indicate if end() was called\n\n  push(message: T) {\n    if (this.ended) {\n      // Don't push messages after the queue has ended\n      return\n    }\n    if (this.resolver) {\n      this.resolver({value: message, done: false})\n      this.resolver = null\n    } else {\n      this.queue.push(message)\n    }\n  }\n\n  next(): Promise<IteratorResult<T>> {\n    if (this.queue.length) {\n      return Promise.resolve({value: this.queue.shift()!, done: false})\n    }\n\n    if (this.ended) {\n      // If end() was called before and queue is empty, resolve immediately as done\n      return Promise.resolve({value: undefined, done: true})\n    }\n\n    return new Promise((resolve) => (this.resolver = resolve))\n  }\n\n  end() {\n    if (this.resolver) {\n      this.resolver({value: undefined, done: true})\n      this.resolver = null // Clear resolver after ending\n    } else {\n      // If resolver is null, it means next() hasn't been called yet or\n      // previous next() was resolved by a push(). Mark as ended so the\n      // *next* call to next() resolves immediately as done.\n      this.ended = true\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<{type: 'error'; error: unknown}>()\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({type: 'error', error})\n  }\n\n  worker.addListener('message', handleMessage)\n  worker.addListener('error', handleError)\n\n  return {\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 {value, done} = 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    dispose: () => {\n      worker.removeListener('message', handleMessage)\n      worker.removeListener('error', handleError)\n      return worker.terminate()\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 *\n * @internal\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 = {type: 'event', name, payload}\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 = {type: 'emission', name, payload}\n            parentPort.postMessage(message)\n          },\n          end: () => {\n            const message: StreamEndMessage = {type: 'end', name}\n            parentPort.postMessage(message)\n          },\n        }\n\n        return streamReporter\n      },\n    }),\n  }\n}\n"],"names":[],"mappings":"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"}

package/src/util/__tests__/workerChannel.test.ts

@@ -1,222 +0,0 @@
-import {EventEmitter} from 'node:events'
-import {type MessagePort, type Worker} from 'node:worker_threads'
-
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {
-  createReceiver,
-  createReporter,
-  type WorkerChannel,
-  type WorkerChannelEvent,
-  type WorkerChannelStream,
-} from '../workerChannel'
-
-// Define a sample worker channel for testing
-type TestWorkerChannel = WorkerChannel<{
-  simpleEvent: WorkerChannelEvent<string>
-  dataEvent: WorkerChannelEvent<{id: number; value: boolean}>
-  simpleStream: WorkerChannelStream<number>
-  endStream: WorkerChannelStream<void>
-}>
-
-// Mock Worker and MessagePort
-class MockWorker extends EventEmitter {
-  terminated = false
-  terminate = vi.fn(async () => {
-    this.terminated = true
-    return 0
-  })
-  postMessage = vi.fn((message: unknown) => {
-    this.emit('message', message)
-  })
-
-  // Helper to simulate receiving a message from the parent (if needed)
-  receiveMessage(message: unknown) {
-    this.emit('message', message)
-  }
-
-  // Helper to simulate an error from the worker
-  emitError(error: unknown) {
-    this.emit('error', error)
-  }
-}
-
-class MockMessagePort extends EventEmitter {
-  postMessage = vi.fn((message: unknown) => {
-    // Simulate the message being sent back to the parent/receiver
-    // In a real scenario, this would go to the Worker's listener
-    mockWorkerInstance?.receiveMessage(message)
-  })
-
-  // Helper to simulate receiving a message (e.g., from the parent)
-  receiveMessage(message: unknown) {
-    this.emit('message', message)
-  }
-}
-
-let mockWorkerInstance: MockWorker
-let mockParentPortInstance: MockMessagePort
-let receiver: ReturnType<typeof createReceiver<TestWorkerChannel>>
-let reporter: ReturnType<typeof createReporter<TestWorkerChannel>>
-
-beforeEach(() => {
-  mockWorkerInstance = new MockWorker()
-  mockParentPortInstance = new MockMessagePort()
-  receiver = createReceiver<TestWorkerChannel>(mockWorkerInstance as unknown as Worker)
-  reporter = createReporter<TestWorkerChannel>(mockParentPortInstance as unknown as MessagePort)
-})
-
-afterEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('workerChannel', () => {
-  it('should send and receive a simple event', async () => {
-    const receivedPromise = receiver.event.simpleEvent()
-    reporter.event.simpleEvent('hello')
-
-    await expect(receivedPromise).resolves.toBe('hello')
-  })
-
-  it('should send and receive an event with data object', async () => {
-    const payload = {id: 123, value: true}
-    const receivedPromise = receiver.event.dataEvent()
-    reporter.event.dataEvent(payload)
-
-    await expect(receivedPromise).resolves.toEqual(payload)
-  })
-
-  it('should send and receive a stream of data', async () => {
-    const receivedItems: number[] = []
-    const streamPromise = (async () => {
-      for await (const item of receiver.stream.simpleStream()) {
-        receivedItems.push(item)
-      }
-    })()
-
-    reporter.stream.simpleStream.emit(1)
-    reporter.stream.simpleStream.emit(2)
-    reporter.stream.simpleStream.emit(3)
-    reporter.stream.simpleStream.end()
-
-    await streamPromise // Wait for the stream processing to complete
-
-    expect(receivedItems).toEqual([1, 2, 3])
-  })
-
-  it('should handle an empty stream correctly', async () => {
-    let streamEntered = false
-    const streamPromise = (async () => {
-      for await (const _item of receiver.stream.endStream()) {
-        streamEntered = true // This should not happen
-      }
-    })()
-
-    reporter.stream.endStream.end() // End immediately
-
-    await streamPromise
-
-    expect(streamEntered).toBe(false)
-  })
-
-  it('should propagate errors from the worker via event receiver', async () => {
-    const error = new Error('Worker failed')
-
-    const receivedPromise = receiver.event.simpleEvent()
-    mockWorkerInstance?.emitError(error)
-
-    await expect(receivedPromise).rejects.toThrow(error)
-  })
-
-  it('should propagate errors from the worker via stream receiver', async () => {
-    const error = new Error('Worker failed during stream')
-
-    const streamPromise = (async () => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      for await (const _item of receiver.stream.simpleStream()) {
-        // no-op
-      }
-    })()
-
-    // Emit error before ending the stream
-    mockWorkerInstance?.emitError(error)
-
-    await expect(streamPromise).rejects.toThrow(error)
-  })
-
-  it('should handle messages arriving before receiver awaits', async () => {
-    // Reporter sends event *before* receiver awaits it
-    reporter.event.simpleEvent('early bird')
-
-    // Give a tick for the message to be processed internally by the mock
-    await new Promise((resolve) => setImmediate(resolve))
-
-    const receivedPromise = receiver.event.simpleEvent()
-
-    await expect(receivedPromise).resolves.toBe('early bird')
-  })
-
-  it('should handle stream emissions arriving before receiver iterates', async () => {
-    // Reporter sends stream data *before* receiver starts iterating
-    reporter.stream.simpleStream.emit(10)
-    reporter.stream.simpleStream.emit(20)
-
-    // Give a tick for messages to process
-    await new Promise((resolve) => setImmediate(resolve))
-
-    const receivedItems: number[] = []
-    const streamPromise = (async () => {
-      for await (const item of receiver.stream.simpleStream()) {
-        receivedItems.push(item)
-      }
-    })()
-
-    // Send remaining data and end
-    reporter.stream.simpleStream.emit(30)
-    reporter.stream.simpleStream.end()
-
-    await streamPromise
-
-    expect(receivedItems).toEqual([10, 20, 30])
-  })
-
-  it('dispose() should remove listeners and terminate worker', async () => {
-    expect(mockWorkerInstance?.listenerCount('message')).toBe(1)
-    expect(mockWorkerInstance?.listenerCount('error')).toBe(1)
-
-    const terminatePromise = receiver.dispose()
-
-    await expect(terminatePromise).resolves.toBe(0)
-    expect(mockWorkerInstance?.terminate).toHaveBeenCalledTimes(1)
-    expect(mockWorkerInstance?.listenerCount('message')).toBe(0)
-    expect(mockWorkerInstance?.listenerCount('error')).toBe(0)
-    expect(mockWorkerInstance?.terminated).toBe(true)
-  })
-
-  it('should throw error if parentPort is null for reporter', () => {
-    expect(() => createReporter<TestWorkerChannel>(null)).toThrow('parentPart was falsy')
-  })
-
-  it('should ignore non-worker channel messages', async () => {
-    const receivedPromise = receiver.event.simpleEvent()
-
-    // Send a valid message
-    reporter.event.simpleEvent('valid')
-    await expect(receivedPromise).resolves.toBe('valid')
-
-    const nextReceivedPromise = receiver.event.simpleEvent()
-
-    // Send an invalid message
-    mockWorkerInstance?.receiveMessage({foo: 'bar'}) // Not a valid WorkerChannelMessage
-    mockWorkerInstance?.receiveMessage('just a string')
-    mockWorkerInstance?.receiveMessage(null)
-    mockWorkerInstance?.receiveMessage(undefined)
-    mockWorkerInstance?.receiveMessage({type: 'unknown'})
-
-    // Send the actual message we are waiting for
-    reporter.event.simpleEvent('after invalid')
-
-    // It should eventually resolve with the correct message, ignoring the invalid ones
-    await expect(nextReceivedPromise).resolves.toBe('after invalid')
-  })
-})