osra 0.1.0 → 0.1.1

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import type { RemoteTarget, LocalTarget, OsraMessage, StructuredCloneTransferableProxiableType } from './types';
+export * from './utils';
+export declare const expose: <T extends StructuredCloneTransferableProxiableType>(value: StructuredCloneTransferableProxiableType, { remote: _remote, local: _local, key, origin }: {
+    remote: RemoteTarget | ((osraMessage: OsraMessage, transferables: Transferable[]) => void);
+    local: LocalTarget | ((listener: (event: MessageEvent<OsraMessage>) => void) => void);
+    key?: string;
+    origin?: string;
+}) => Promise<T>;

package/build/types.d.ts

@@ -0,0 +1,66 @@
+export declare const OSRA_MESSAGE_PROPERTY: "__OSRA__";
+export declare const OSRA_MESSAGE_KEY: "__OSRA_DEFAULT_KEY__";
+export declare const OSRA_PROXY: "__OSRA_PROXY__";
+export type JsonPropertyKey = string | number;
+export type JsonCloneType = boolean | null | number | string | {
+    [key: string]: JsonCloneType;
+} | Array<JsonCloneType>;
+export type StructuredCloneType = JsonCloneType | void | undefined | BigInt | Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | {
+    [key: string]: StructuredCloneType;
+} | Array<StructuredCloneType> | Map<StructuredCloneType, StructuredCloneType> | Set<StructuredCloneType>;
+export type TransferableObject = SharedArrayBuffer | ArrayBuffer | MessagePort | ReadableStream;
+export type StructuredCloneTransferableType = StructuredCloneType | TransferableObject | {
+    [key: string]: StructuredCloneTransferableType;
+} | Array<StructuredCloneTransferableType> | Map<StructuredCloneTransferableType, StructuredCloneTransferableType> | Set<StructuredCloneTransferableType>;
+export type ProxiableType = Promise<StructuredCloneTransferableProxiableType> | Error | MessagePort | ReadableStream | ((...args: any[]) => Promise<StructuredCloneTransferableProxiableType>) | {
+    [key: string]: StructuredCloneTransferableProxiableType;
+} | Array<StructuredCloneTransferableProxiableType> | Map<StructuredCloneTransferableProxiableType, StructuredCloneTransferableProxiableType> | Set<StructuredCloneTransferableProxiableType>;
+export type StructuredCloneTransferableProxiableType = ProxiableType | StructuredCloneTransferableType;
+type PortOrJsonPort<JsonOnly extends boolean> = JsonOnly extends true ? {
+    portId: string;
+} : {
+    port: MessagePort;
+};
+export type ProxiedFunctionType<JsonOnly extends boolean> = ({
+    type: 'function';
+} & PortOrJsonPort<JsonOnly>);
+export type ProxiedMessagePortType<JsonOnly extends boolean> = ({
+    type: 'messagePort';
+} & PortOrJsonPort<JsonOnly>);
+export type ProxiedPromiseType<JsonOnly extends boolean> = ({
+    type: 'promise';
+} & PortOrJsonPort<JsonOnly>);
+export type ProxiedReadableStreamType<JsonOnly extends boolean> = ({
+    type: 'readableStream';
+} & PortOrJsonPort<JsonOnly>);
+export type ProxiedErrorType = ({
+    type: 'error';
+    message: string;
+    stack?: string;
+});
+export type ProxiedType<JsonOnly extends boolean> = {
+    [OSRA_PROXY]: true;
+} & (ProxiedFunctionType<JsonOnly> | ProxiedMessagePortType<JsonOnly> | ProxiedPromiseType<JsonOnly> | ProxiedReadableStreamType<JsonOnly> | ProxiedErrorType);
+export type OsraMessage = {
+    [OSRA_MESSAGE_PROPERTY]: true;
+    key: string;
+} & ({
+    type: 'ready';
+    envCheck: {
+        buffer: ArrayBuffer;
+        port: MessagePort;
+    };
+} | {
+    type: 'init';
+    data: StructuredCloneTransferableType;
+} | {
+    type: 'message';
+    portId: string;
+    data: any;
+} | {
+    type: 'port-closed';
+    portId: string;
+});
+export type RemoteTarget = Window | ServiceWorker | Worker | MessagePort;
+export type LocalTarget = WindowEventHandlers | ServiceWorkerContainer | Worker | SharedWorker;
+export {};

package/build/utils.d.ts

@@ -0,0 +1,60 @@
+import type { StructuredCloneTransferableType, TransferableObject, ProxiedErrorType, ProxiedFunctionType, ProxiedMessagePortType, ProxiedPromiseType, StructuredCloneTransferableProxiableType } from './types';
+export declare const isClonable: (value: any) => boolean;
+export declare const isTransferable: (value: any) => boolean;
+export declare const getTransferableObjects: (value: any) => TransferableObject[];
+export type EnvCheck = {
+    uuid: string;
+    supportsPorts: boolean;
+    jsonOnly: boolean;
+};
+export type Context = {
+    envCheck: EnvCheck;
+    addIncomingProxiedMessagePort: (portId: string) => MessagePort;
+    addOutgoingProxiedMessagePort: (port: MessagePort) => string;
+    finalizationRegistry: FinalizationRegistry<number>;
+};
+export declare const proxiedFunctionToFunction: <JsonOnly extends boolean>(proxiedFunction: ProxiedFunctionType<JsonOnly>, context: Context) => (...args: StructuredCloneTransferableType[]) => Promise<unknown>;
+export declare const proxiedMessagePortToMessagePort: <JsonOnly extends boolean>(proxiedMessagePort: ProxiedMessagePortType<JsonOnly>, context: Context) => MessagePort;
+export declare const proxiedErrorToError: (proxiedError: ProxiedErrorType, context: Context) => Error;
+export declare const proxiedPromiseToPromise: <JsonOnly extends boolean>(proxiedPromise: ProxiedPromiseType<JsonOnly>, context: Context) => Promise<unknown>;
+export declare const replaceIncomingProxiedTypes: (value: StructuredCloneTransferableType, context: Context) => StructuredCloneTransferableProxiableType;
+export declare const errorToProxiedError: (error: Error, _: Context) => {
+    __OSRA_PROXY__: boolean;
+    type: string;
+    message: string;
+    stack: string | undefined;
+};
+export declare const messagePortToProxiedMessagePort: (port: MessagePort, context: Context) => {
+    port: MessagePort;
+    __OSRA_PROXY__: boolean;
+    type: string;
+} | {
+    portId: string;
+    __OSRA_PROXY__: boolean;
+    type: string;
+};
+export declare const promiseToProxiedPromise: (promise: Promise<StructuredCloneTransferableType>, context: Context) => {
+    __OSRA_PROXY__: boolean;
+    type: string;
+    port: any;
+};
+export declare const functionToProxiedFunction: (func: Function, context: Context) => {
+    __OSRA_PROXY__: boolean;
+    type: string;
+    port: any;
+};
+export declare const replaceOutgoingProxiedTypes: <T extends StructuredCloneTransferableProxiableType>(value: T, context: Context) => any;
+export declare const replaceRecursive: <T extends StructuredCloneTransferableProxiableType, T2 extends (value: any) => any>(value: T, shouldReplace: (value: Parameters<T2>[0]) => boolean, replaceFunction: T2) => any;
+export declare const makeNumberAllocator: () => {
+    alloc: () => number;
+    free: (number: any) => void;
+};
+type NumberAllocator = ReturnType<typeof makeNumberAllocator>;
+export declare const makeAllocator: <T>({ numberAllocator }: {
+    numberAllocator: NumberAllocator;
+}) => {
+    alloc: (value: T) => number;
+    get: (id: number) => T | undefined;
+    free: (id: number) => void;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Easy communication between workers",
   "files": [
     "build"
@@ -8,7 +8,7 @@
   "main": "build/index.js",
   "type": "module",
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && tsc",
     "build-watch": "vite build --watch",
     "build-test": "vite build --config vite.test.config.ts",
     "build-test-watch": "vite build --config vite.test.config.ts --watch",