@slates/provider 1.0.0-rc.19 → 1.0.0-rc.20

package/dist/index.cjs

@@ -2264,7 +2264,28 @@ var config = (schema) => SlateConfig.create(schema);
 
 // src/context/context.ts
 var import_node_stream = require("stream");
+
+// src/context/pQueue.ts
 var import_p_queue = __toESM(require("p-queue"), 1);
+
+// src/module/resolveDefaultExport.ts
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+
+// src/context/pQueue.ts
+var PQueue = resolveDefaultExport(import_p_queue.default);
+
+// src/context/context.ts
 var isBufferLike = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
 var toUint8Array = (value) => value instanceof ArrayBuffer ? new Uint8Array(value) : value;
 var isReadableStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
@@ -2295,7 +2316,13 @@ var SlatePublicContext = class {
   #attachmentsDisabled = false;
   #attachments = [];
   #pendingUploads = [];
-  #uploadQueue = new import_p_queue.default({ concurrency: 10 });
+  #uploadQueue;
+  #getUploadQueue() {
+    if (!this.#uploadQueue) {
+      this.#uploadQueue = new PQueue({ concurrency: 10 });
+    }
+    return this.#uploadQueue;
+  }
   get specification() {
     return this.spec;
   }
@@ -2383,7 +2410,7 @@ var SlatePublicContext = class {
       return;
     }
     let live = this.#liveInvocation;
-    let task = this.#uploadQueue.add(
+    let task = this.#getUploadQueue().add(
       () => uploadAttachmentDirect({
         live,
         mimeType: normalized.mimeType,

package/dist/index.module.js

@@ -2155,7 +2155,28 @@ var config = (schema) => SlateConfig.create(schema);
 
 // src/context/context.ts
 import { Readable } from "stream";
-import PQueue from "p-queue";
+
+// src/context/pQueue.ts
+import PQueueImport from "p-queue";
+
+// src/module/resolveDefaultExport.ts
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+
+// src/context/pQueue.ts
+var PQueue = resolveDefaultExport(PQueueImport);
+
+// src/context/context.ts
 var isBufferLike = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
 var toUint8Array = (value) => value instanceof ArrayBuffer ? new Uint8Array(value) : value;
 var isReadableStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
@@ -2186,7 +2207,13 @@ var SlatePublicContext = class {
   #attachmentsDisabled = false;
   #attachments = [];
   #pendingUploads = [];
-  #uploadQueue = new PQueue({ concurrency: 10 });
+  #uploadQueue;
+  #getUploadQueue() {
+    if (!this.#uploadQueue) {
+      this.#uploadQueue = new PQueue({ concurrency: 10 });
+    }
+    return this.#uploadQueue;
+  }
   get specification() {
     return this.spec;
   }
@@ -2274,7 +2301,7 @@ var SlatePublicContext = class {
       return;
     }
     let live = this.#liveInvocation;
-    let task = this.#uploadQueue.add(
+    let task = this.#getUploadQueue().add(
       () => uploadAttachmentDirect({
         live,
         mimeType: normalized.mimeType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.19",
+  "version": "1.0.0-rc.20",
   "publishConfig": {
     "access": "public"
   },

package/src/context/context.ts

@@ -1,5 +1,4 @@
 import { Readable } from 'node:stream';
-import PQueue from 'p-queue';
 import {
   createBase64Attachment,
   createUrlAttachment,
@@ -9,6 +8,7 @@ import { type SlateLiveInvocationInfo, uploadAttachmentDirect } from '../action/
 import type { SlateHttpTrace } from '../axios/trace';
 import type { SlateLogger, SlateLogMessageInput } from '../logger';
 import type { SlateSpecification } from '../specification/specification';
+import { PQueue } from './pQueue';
 
 export type { SlateLiveInvocationInfo };
 
@@ -83,7 +83,14 @@ export class SlatePublicContext<InputType extends {}> {
   #attachmentsDisabled = false;
   #attachments: SlateAttachment[] = [];
   #pendingUploads: Promise<void>[] = [];
-  #uploadQueue = new PQueue({ concurrency: 10 });
+  #uploadQueue?: InstanceType<typeof PQueue>;
+
+  #getUploadQueue() {
+    if (!this.#uploadQueue) {
+      this.#uploadQueue = new PQueue({ concurrency: 10 });
+    }
+    return this.#uploadQueue;
+  }
 
   constructor(
     input: InputType,
@@ -207,7 +214,7 @@ export class SlatePublicContext<InputType extends {}> {
     }
 
     let live = this.#liveInvocation;
-    let task = this.#uploadQueue
+    let task = this.#getUploadQueue()
       .add(() =>
         uploadAttachmentDirect({
           live,

package/src/context/hook.test.ts

@@ -3,6 +3,25 @@ import { SlateContext } from './context';
 import { runWithContext } from './hook';
 
 describe('slate context hook', () => {
+  it('constructs a context without requiring p-queue at construction time', () => {
+    expect(
+      () =>
+        new SlateContext(
+          {},
+          {},
+          {},
+          {} as any,
+          {
+            debug: () => {},
+            error: () => {},
+            info: () => {},
+            progress: () => {},
+            warn: () => {}
+          } as any
+        )
+    ).not.toThrow();
+  });
+
   it('shares context storage across duplicate module instances', async () => {
     // @ts-expect-error Vite treats the query as a distinct module instance.
     let duplicateHook: typeof import('./hook') = await import('./hook?duplicate-instance');

package/src/context/pQueue.ts

@@ -0,0 +1,4 @@
+import PQueueImport from 'p-queue';
+import { resolveDefaultExport } from '../module/resolveDefaultExport';
+
+export let PQueue = resolveDefaultExport<typeof PQueueImport>(PQueueImport);

package/src/module/resolveDefaultExport.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { resolveDefaultExport } from './resolveDefaultExport';
+
+class Example {
+  value: number;
+  constructor(value: number) {
+    this.value = value;
+  }
+}
+
+describe('resolveDefaultExport', () => {
+  it('returns a constructor export as-is', () => {
+    expect(resolveDefaultExport<typeof Example>(Example)).toBe(Example);
+    expect(new (resolveDefaultExport<typeof Example>(Example))(1).value).toBe(1);
+  });
+
+  it('unwraps CJS default-export objects produced by bundlers', () => {
+    expect(resolveDefaultExport<typeof Example>({ default: Example })).toBe(Example);
+  });
+
+  it('unwraps nested default exports from double-bundling', () => {
+    expect(
+      resolveDefaultExport<typeof Example>({ default: { default: Example } })
+    ).toBe(Example);
+  });
+
+  it('throws when the export is not a constructor', () => {
+    expect(() => resolveDefaultExport({})).toThrow(TypeError);
+    expect(() => resolveDefaultExport({ default: { foo: 1 } })).toThrow(TypeError);
+    expect(() => resolveDefaultExport(undefined)).toThrow(TypeError);
+  });
+});

package/src/module/resolveDefaultExport.ts

@@ -0,0 +1,14 @@
+export let resolveDefaultExport = <T>(value: unknown): T => {
+  let current = value;
+
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === 'function') return current as T;
+    if (current && typeof current === 'object' && 'default' in current) {
+      current = (current as { default: unknown }).default;
+      continue;
+    }
+    break;
+  }
+
+  throw new TypeError('Module export is not a constructor');
+};