@milkio/stargate-worker 1.0.0-beta.28 → 1.0.0-beta.30

package/index.d.ts

@@ -1,9 +1,31 @@
 export type MilkioStargateOptions = {
-    postMessage: (data: any) => void;
-    serialize: "native" | "tson" | "json";
+    port: {
+        postMessage: (data: any) => void;
+        addEventListener: (event: "message", callback: (event: {
+            data: any;
+        }) => void) => void;
+        removeEventListener: (event: "message", callback: (event: {
+            data: any;
+        }) => void) => void;
+    };
 };
 export type Mixin<T, U> = U & Omit<T, keyof U>;
+export type ExecuteOptions = {
+    params?: Record<any, any>;
+    headers?: Record<string, string>;
+    type?: "action" | "stream";
+};
+export type ExecuteResultsOption = {
+    executeId: string;
+};
+export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
 export declare function createStargateWorker<Generated extends {
     routeSchema: any;
     rejectCode: any;
-}>(stargateOptions: MilkioStargateOptions): Promise<void>;
+}>(stargateOptions: MilkioStargateOptions): Promise<{
+    execute<Path extends keyof Generated["routeSchema"]>(path: Path, options?: Mixin<ExecuteOptions, {
+        params?: Generated["routeSchema"][Path]["types"]["params"];
+    }>): Promise<Generated["routeSchema"][Path]["types"]["\uD83D\uDC23"] extends boolean ? // action
+    [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"][Path]["types"]["result"], ExecuteResultsOption] : // stream
+    [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"][Path]["types"]["result"]>], ExecuteResultsOption>]>;
+}>;

package/index.js

@@ -1,8 +1,230 @@
+// packages/milkio-stargate-worker/utils/create-id.ts
+function defineIdGenerator(options) {
+  if (!options.length)
+    options.length = 24;
+  if (options.length < 1)
+    throw new Error("Invalid length");
+  if (options.length > 61)
+    throw new Error("Invalid length");
+  if (options.timestamp && options.length < 9)
+    throw new Error("Invalid length");
+  let lastTime = 0;
+  let lastDecimal = 0n;
+  return {
+    createId() {
+      let randLength = options.length;
+      const now = Date.now();
+      let id = "";
+      if (options.timestamp) {
+        randLength -= 8;
+        id = `${id}${__bigIntToString(BigInt(now)).padStart(8, "0")}`;
+      }
+      if (options.sequential && lastTime === now) {
+        id = `${id}${__bigIntToString(++lastDecimal).padStart(1, "0")}`;
+      } else {
+        lastTime = now;
+        const min = 0n;
+        const max = __getMaxValue(BigInt(randLength));
+        lastDecimal = __secureRandomBigInt(min, max);
+        id = `${id}${__bigIntToString(lastDecimal).padStart(randLength, "0")}`;
+      }
+      return id;
+    },
+    getIdTimestamp(id) {
+      return options.timestamp ? Number(__stringToBigInt(id.slice(0, 8).replaceAll("0", ""))) : 0;
+    }
+  };
+}
+var ENCODING = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function __secureRandomBigInt(min, max) {
+  if (min >= max)
+    throw new Error("Invalid range");
+  const range = max - min + 1n;
+  const byteCount = Math.ceil(Number(BigInt(range.toString(2).length)) / 8);
+  const entropyBytes = new Uint8Array(byteCount);
+  let randomValue;
+  do {
+    crypto.getRandomValues(entropyBytes);
+    randomValue = BigInt(`0x${Array.from(entropyBytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`) % range;
+  } while (randomValue < 0n);
+  return min + randomValue;
+}
+function __bigIntToString(value) {
+  const base = BigInt(ENCODING.length);
+  let result = "";
+  let current = value;
+  if (current === 0n)
+    return ENCODING[0];
+  while (current > 0n) {
+    const remainder = current % base;
+    result = ENCODING[Number(remainder)] + result;
+    current = current / base;
+  }
+  return result;
+}
+function __stringToBigInt(str) {
+  const charMap = {};
+  for (let i = 0;i < ENCODING.length; i++) {
+    charMap[ENCODING[i]] = i;
+  }
+  const base = BigInt(ENCODING.length);
+  let result = 0n;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (!(char in charMap)) {
+      throw new Error(`Invalid character '${char}' in input string`);
+    }
+    const value = BigInt(charMap[char]);
+    result = result * base + value;
+  }
+  return result;
+}
+function __getMaxValue(n) {
+  return BigInt(ENCODING.length) ** n - 1n;
+}
+var idGenerator = defineIdGenerator({ length: 24, timestamp: false, sequential: false });
+var __createId = idGenerator.createId;
+
 // packages/milkio-stargate-worker/index.ts
-async function createStargateWorker(stargateOptions) {}
+async function createStargateWorker(stargateOptions) {
+  const connect = new Promise((resolve) => {
+    const handler = (event) => {
+      if (event.data !== "PONG")
+        return;
+      clearInterval(timer);
+      stargateOptions.port.removeEventListener("message", handler);
+      resolve(true);
+    };
+    stargateOptions.port.addEventListener("message", handler);
+    stargateOptions.port.postMessage("PING");
+    const timer = setInterval(() => stargateOptions.port.postMessage("PING"), 42);
+  });
+  const stargate = {
+    async execute(path, options) {
+      return new Promise(async (resolve, reject) => {
+        await connect;
+        const executeId = __createId();
+        if (options?.type === "action" || !options?.type) {
+          const handler = (event) => {
+            if (typeof event.data !== "object")
+              return;
+            if (event.data.executeId !== executeId)
+              return;
+            stargateOptions.port.removeEventListener("message", handler);
+            if (!event.data.success)
+              resolve([event.data.error, null, { executeId }]);
+            if (event.data.success)
+              resolve([null, event.data.data, { executeId }]);
+          };
+          stargateOptions.port.addEventListener("message", handler);
+          stargateOptions.port.postMessage({
+            executeId,
+            path,
+            params: options?.params,
+            headers: options?.headers
+          });
+        }
+        if (options?.type === "stream") {
+          let generator;
+          const handler = (event) => {
+            if (typeof event.data !== "object")
+              return;
+            if (event.data.executeId !== executeId)
+              return;
+            stargateOptions.port.removeEventListener("message", handler);
+            if (!generator) {
+              generator = createControllableAsyncGenerator();
+              if (!event.data.success)
+                resolve([event.data.error, null, { executeId }]);
+              if (event.data.success)
+                resolve([null, generator, { executeId }]);
+            } else {
+              if (event.data.done)
+                generator.complete();
+              else if (event.data.success)
+                generator.push(event.data.data);
+              else if (!event.data.success)
+                generator.error(event.data.data);
+            }
+          };
+          stargateOptions.port.addEventListener("message", handler);
+          stargateOptions.port.postMessage({
+            executeId,
+            path,
+            params: options?.params,
+            headers: options?.headers
+          });
+        }
+      });
+    }
+  };
+  return stargate;
+}
+function createControllableAsyncGenerator() {
+  const queue = [];
+  let deferred = null;
+  let finished = false;
+  const processQueue = () => {
+    if (deferred && queue.length > 0) {
+      const item = queue.shift();
+      if (item.error) {
+        deferred.reject(item.error);
+      } else {
+        deferred.resolve({ value: item.value, done: item.done || false });
+      }
+      deferred = null;
+    }
+  };
+  const generator = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      if (finished)
+        return { value: undefined, done: true };
+      return new Promise((resolve, reject) => {
+        deferred = { resolve, reject };
+        processQueue();
+      });
+    },
+    async return(value) {
+      finished = true;
+      queue.length = 0;
+      return { value, done: true };
+    },
+    async throw(error) {
+      finished = true;
+      queue.length = 0;
+      return Promise.reject(error);
+    }
+  };
+  return {
+    generator,
+    push: (value) => {
+      if (finished)
+        return;
+      queue.push({ value });
+      processQueue();
+    },
+    complete: (value) => {
+      if (finished)
+        return;
+      finished = true;
+      queue.push({ done: true, value });
+      processQueue();
+    },
+    error: (err) => {
+      if (finished)
+        return;
+      finished = true;
+      queue.push({ error: err });
+      processQueue();
+    }
+  };
+}
 export {
   createStargateWorker
 };
 
-//# debugId=AA43A045845D544164756E2164756E21
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi5cXGluZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWwogICAgImltcG9ydCB7IFRTT04gfSBmcm9tIFwiQHNvdXRoZXJuLWF1cm9yYS90c29uXCI7XG5cbmV4cG9ydCB0eXBlIE1pbGtpb1N0YXJnYXRlT3B0aW9ucyA9IHtcbiAgcG9zdE1lc3NhZ2U6IChkYXRhOiBhbnkpID0+IHZvaWQ7XG4gIHNlcmlhbGl6ZTogXCJuYXRpdmVcIiB8IFwidHNvblwiIHwgXCJqc29uXCI7XG59O1xuXG5leHBvcnQgdHlwZSBNaXhpbjxULCBVPiA9IFUgJiBPbWl0PFQsIGtleW9mIFU+O1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY3JlYXRlU3RhcmdhdGVXb3JrZXI8XG4gIEdlbmVyYXRlZCBleHRlbmRzIHsgcm91dGVTY2hlbWE6IGFueTsgcmVqZWN0Q29kZTogYW55IH1cbj4oc3RhcmdhdGVPcHRpb25zOiBNaWxraW9TdGFyZ2F0ZU9wdGlvbnMpIHtcbiAgLy9cbn1cbiIKICBdLAogICJtYXBwaW5ncyI6ICI7QUFTQSxlQUFzQixvQkFFckIsQ0FBQyxpQkFBd0M7IiwKICAiZGVidWdJZCI6ICJBQTQzQTA0NTg0NUQ1NDQxNjQ3NTZFMjE2NDc1NkUyMSIsCiAgIm5hbWVzIjogW10KfQ==
+//# debugId=C3A691A15581F6EE64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\utils\\create-id.ts", "..\\index.ts"],
  "sourcesContent": [
    "type IdGeneratorOptions = {\n  length?: number;\n  timestamp: boolean;\n  sequential: boolean;\n};\n\nfunction defineIdGenerator(options: IdGeneratorOptions) {\n  if (!options.length) options.length = 24;\n  if (options.length < 1) throw new Error(\"Invalid length\");\n  if (options.length > 61) throw new Error(\"Invalid length\");\n  if (options.timestamp && options.length < 9) throw new Error(\"Invalid length\");\n  let lastTime = 0;\n  let lastDecimal = 0n;\n  return {\n    createId() {\n      let randLength = options.length!;\n      const now = Date.now();\n      let id = \"\";\n      if (options.timestamp) {\n        randLength -= 8;\n        id = `${id}${__bigIntToString(BigInt(now)).padStart(8, \"0\")}`;\n      }\n      if (options.sequential && lastTime === now) {\n        id = `${id}${__bigIntToString(++lastDecimal).padStart(1, \"0\")}`;\n      } else {\n        lastTime = now;\n        const min = 0n;\n        const max = __getMaxValue(BigInt(randLength));\n        lastDecimal = __secureRandomBigInt(min, max);\n        id = `${id}${__bigIntToString(lastDecimal).padStart(randLength, \"0\")}`;\n      }\n      return id;\n    },\n    getIdTimestamp(id: string) {\n      return options.timestamp ? Number(__stringToBigInt(id.slice(0, 8).replaceAll(\"0\", \"\"))) : 0;\n    },\n  };\n}\n\nconst ENCODING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n\nfunction __secureRandomBigInt(min: bigint, max: bigint): bigint {\n  if (min >= max) throw new Error(\"Invalid range\");\n\n  const range = max - min + 1n;\n  const byteCount = Math.ceil(Number(BigInt(range.toString(2).length)) / 8);\n  const entropyBytes = new Uint8Array(byteCount);\n\n  let randomValue: bigint;\n  do {\n    crypto.getRandomValues(entropyBytes);\n    randomValue =\n      BigInt(\n        `0x${Array.from(entropyBytes)\n          .map((b) => b.toString(16).padStart(2, \"0\"))\n          .join(\"\")}`,\n      ) % range;\n  } while (randomValue < 0n);\n\n  return min + randomValue;\n}\n\nfunction __bigIntToString(value: bigint): string {\n  const base = BigInt(ENCODING.length);\n  let result = \"\";\n  let current = value;\n\n  if (current === 0n) return ENCODING[0];\n\n  while (current > 0n) {\n    const remainder = current % base;\n    result = ENCODING[Number(remainder)] + result;\n    current = current / base;\n  }\n  return result;\n}\n\nfunction __stringToBigInt(str: string): bigint {\n  const charMap: { [key: string]: number } = {};\n  for (let i = 0; i < ENCODING.length; i++) {\n    charMap[ENCODING[i]] = i;\n  }\n\n  const base = BigInt(ENCODING.length);\n  let result = 0n;\n\n  for (let i = 0; i < str.length; i++) {\n    const char = str[i];\n    if (!(char in charMap)) {\n      throw new Error(`Invalid character '${char}' in input string`);\n    }\n    const value = BigInt(charMap[char]);\n    result = result * base + value;\n  }\n\n  return result;\n}\n\nfunction __getMaxValue(n: bigint): bigint {\n  return BigInt(ENCODING.length) ** n - 1n;\n}\n\nconst idGenerator = defineIdGenerator({ length: 24, timestamp: false, sequential: false });\n\nexport const __createId = idGenerator.createId;\n",
    "import { __createId } from \"./utils/create-id.ts\";\n\nexport type MilkioStargateOptions = {\n  port: {\n    postMessage: (data: any) => void;\n    addEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n    removeEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n  };\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type ExecuteOptions = {\n  params?: Record<any, any>;\n  headers?: Record<string, string>;\n  type?: \"action\" | \"stream\";\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport async function createStargateWorker<Generated extends { routeSchema: any; rejectCode: any }>(stargateOptions: MilkioStargateOptions) {\n  const connect = new Promise((resolve) => {\n    const handler = (event: { data: any }) => {\n      if (event.data !== \"PONG\") return;\n      clearInterval(timer);\n      stargateOptions.port.removeEventListener(\"message\", handler);\n      resolve(true);\n    };\n    stargateOptions.port.addEventListener(\"message\", handler);\n    stargateOptions.port.postMessage(\"PING\");\n    const timer = setInterval(() => stargateOptions.port.postMessage(\"PING\"), 42);\n  });\n  const stargate = {\n    async execute<Path extends keyof Generated[\"routeSchema\"]>(\n      path: Path,\n      options?: Mixin<\n        ExecuteOptions,\n        {\n          params?: Generated[\"routeSchema\"][Path][\"types\"][\"params\"];\n        }\n      >,\n    ): Promise<\n      Generated[\"routeSchema\"][Path][\"types\"][\"🐣\"] extends boolean\n        ? // action\n          [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, Generated[\"routeSchema\"][Path][\"types\"][\"result\"], ExecuteResultsOption]\n        : // stream\n          [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated[\"rejectCode\"]>, null] | [null, GeneratorGeneric<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>], ExecuteResultsOption>]\n    > {\n      // biome-ignore lint/suspicious/noAsyncPromiseExecutor: <explanation>\n      return new Promise(async (resolve, reject) => {\n        await connect;\n        const executeId = __createId();\n        if (options?.type === \"action\" || !options?.type) {\n          const handler = (event: { data: any }) => {\n            if (typeof event.data !== \"object\") return;\n            if (event.data.executeId !== executeId) return;\n            stargateOptions.port.removeEventListener(\"message\", handler);\n            if (!event.data.success) resolve([event.data.error, null, { executeId }]);\n            if (event.data.success) resolve([null, event.data.data, { executeId }] as any);\n          };\n          stargateOptions.port.addEventListener(\"message\", handler);\n          stargateOptions.port.postMessage({\n            executeId,\n            path,\n            params: options?.params,\n            headers: options?.headers,\n          });\n        }\n        if (options?.type === \"stream\") {\n          let generator: ReturnType<typeof createControllableAsyncGenerator> | undefined;\n          const handler = (event: { data: any }) => {\n            if (typeof event.data !== \"object\") return;\n            if (event.data.executeId !== executeId) return;\n            stargateOptions.port.removeEventListener(\"message\", handler);\n            if (!generator) {\n              generator = createControllableAsyncGenerator();\n              if (!event.data.success) resolve([event.data.error, null, { executeId }]);\n              if (event.data.success) resolve([null, generator, { executeId }] as any);\n            } else {\n              if (event.data.done) generator.complete();\n              else if (event.data.success) generator.push(event.data.data);\n              else if (!event.data.success) generator.error(event.data.data);\n            }\n          };\n          stargateOptions.port.addEventListener(\"message\", handler);\n          stargateOptions.port.postMessage({\n            executeId,\n            path,\n            params: options?.params,\n            headers: options?.headers,\n          });\n        }\n      });\n    },\n  };\n\n  return stargate;\n}\n\ntype Deferred<T> = {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: any) => void;\n};\n\nfunction createControllableAsyncGenerator<T>(): {\n  generator: AsyncGenerator<T>;\n  push: (value: T) => void;\n  complete: (returnValue?: T) => void;\n  error: (error: Error) => void;\n} {\n  const queue: Array<{ value?: T; done?: boolean; error?: Error }> = [];\n  let deferred: Deferred<IteratorResult<T>> | null = null;\n  let finished = false;\n\n  const processQueue = () => {\n    if (deferred && queue.length > 0) {\n      const item = queue.shift()!;\n      if (item.error) {\n        deferred.reject(item.error);\n      } else {\n        deferred.resolve({ value: item.value!, done: item.done || false });\n      }\n      deferred = null;\n    }\n  };\n\n  const generator: AsyncGenerator<T> = {\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n\n    async next(): Promise<IteratorResult<T>> {\n      if (finished) return { value: undefined, done: true };\n\n      return new Promise((resolve, reject) => {\n        deferred = { resolve, reject };\n        processQueue();\n      });\n    },\n\n    async return(value?: T): Promise<IteratorResult<T>> {\n      finished = true;\n      queue.length = 0;\n      return { value, done: true };\n    },\n\n    async throw(error?: Error): Promise<IteratorResult<T>> {\n      finished = true;\n      queue.length = 0;\n      return Promise.reject(error);\n    },\n  } as any;\n\n  return {\n    generator,\n    push: (value: T) => {\n      if (finished) return;\n      queue.push({ value });\n      processQueue();\n    },\n    complete: (value?: T) => {\n      if (finished) return;\n      finished = true;\n      queue.push({ done: true, value });\n      processQueue();\n    },\n    error: (err: Error) => {\n      if (finished) return;\n      finished = true;\n      queue.push({ error: err });\n      processQueue();\n    },\n  };\n}\n"
  ],
  "mappings": "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",
  "debugId": "C3A691A15581F6EE64756E2164756E21",
  "names": []
}

package/package.json

@@ -1 +1 @@
-{"name":"@milkio/stargate-worker","version":"1.0.0-beta.28","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}
+{"name":"@milkio/stargate-worker","version":"1.0.0-beta.30","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}

package/utils/create-id.d.ts

@@ -0,0 +1 @@
+export declare const __createId: () => string;