coaction 0.0.1 → 0.1.1

package/dist/declarations/src/binder.d.ts

@@ -0,0 +1,27 @@
+import type { Store } from "./interface.js";
+/**
+ * createBinder is a function to create a binder for the 3rd party store.
+ */
+export declare function createBinder<F = (...args: any[]) => any>({ handleState, handleStore }: {
+    /**
+     * handleState is a function to handle the state object.
+     */
+    handleState: <T extends object = object>(state: T) => {
+        /**
+         * copyState is a copy of the state object.
+         */
+        copyState: T;
+        /**
+         * key is the key of the state object.
+         */
+        key?: keyof T;
+        /**
+         * bind is a function to bind the state object.
+         */
+        bind: (state: T) => T;
+    };
+    /**
+     * handleStore is a function to handle the store object.
+     */
+    handleStore: (store: Store<object>, rawState: object, state: object) => void;
+}): F;

package/dist/declarations/src/create.d.ts

@@ -0,0 +1,5 @@
+import type { Creator } from "./interface.js";
+/**
+ * Create a simple store or a shared store. The shared store can be used in a worker or another thread.
+ */
+export declare const create: Creator;

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,4 @@
+export { create } from "./create.js";
+export { createBinder } from "./binder.js";
+export { wrapStore } from "./wrapStore.js";
+export type { Store, StoreOptions, ISlices, Slice, Slices, Middleware, ClientStoreOptions, SliceState, Asyncify, StoreWithAsyncFunction as AsyncStore } from "./interface.js";

package/dist/declarations/src/interface.d.ts

@@ -0,0 +1,224 @@
+import type { Transport } from 'data-transport';
+import type { Draft, Patches } from 'mutative';
+export type ISlices<T = any> = Record<string, T>;
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export type Listener = () => void;
+export interface Store<T extends ISlices = ISlices> {
+    /**
+     * The name of the store.
+     */
+    name: string;
+    /**
+     * Set the next state.
+     */
+    setState: (
+    /**
+     * The next state.
+     */
+    next: DeepPartial<T> | ((draft: Draft<T>) => any) | null, 
+    /**
+     * The updater is used to update the state.
+     */
+    updater?: (next: DeepPartial<T> | ((draft: Draft<T>) => any) | null) => [] | [T, Patches, Patches]) => void;
+    /**
+     * Get the current state.
+     */
+    getState: () => T;
+    /**
+     * Subscribe to the state changes.
+     */
+    subscribe: (listener: Listener) => () => void;
+    /**
+     * Unsubscribe all listeners and dispose the transport.
+     */
+    destroy: () => void;
+    /**
+     * The store is shared in the web worker, shared worker, or other process.
+     */
+    share?: 'main' | 'client' | false;
+    /**
+     * The transport is used to communicate between the main thread and the worker or shared worker.
+     */
+    transport?: Transport;
+    /**
+     * The store is a slices.
+     */
+    isSliceStore: boolean;
+    /**
+     * apply the patches to the state.
+     */
+    apply: (state?: T, patches?: Patches) => void;
+    /**
+     * the pure state is used to get the state without the methods and getters.
+     */
+    getPureState: () => T;
+    /**
+     * Get the initial state.
+     */
+    getInitialState: () => T;
+    /**
+     * Get the raw instance via the initial state.
+     */
+    toRaw?: (key: any) => any;
+    /**
+     * The patch is used to update the state.
+     */
+    patch?: (option: {
+        patches: Patches;
+        inversePatches: Patches;
+    }) => {
+        patches: Patches;
+        inversePatches: Patches;
+    };
+    /**
+     * The act is used to run the function in the action.
+     */
+    act?: <T extends () => any>(fn: T) => ReturnType<T>;
+    /**
+     * The trace is used to trace the action
+     */
+    trace?: (options: {
+        /**
+         * The id of the method.
+         */
+        id: string;
+        /**
+         * The method name.
+         */
+        method: string;
+        /**
+         * The slice key.
+         */
+        sliceKey?: string;
+        /**
+         * The parameters of the method.
+         */
+        parameters?: any[];
+        /**
+         * The result of the method.
+         */
+        result?: any;
+    }) => void;
+}
+export type InternalEvents = {
+    /**
+     * Update the state in the worker or shared worker.
+     */
+    update(options: {
+        /**
+         * The patches is used to update the state.
+         */
+        patches: Patches;
+        /**
+         * The sequence is used to ensure the sequence of the state.
+         */
+        sequence: number;
+    }): Promise<void>;
+};
+export type ExternalEvents = {
+    /**
+     * Execute the function in the worker or shared worker.
+     */
+    execute(keys: string[], args: any[]): Promise<any>;
+    /**
+     * Full sync the state with the worker or shared worker.
+     */
+    fullSync(): Promise<{
+        state: string;
+        sequence: number;
+    }>;
+};
+interface Getter<T extends ISlices> {
+    <P extends any[], R>(getDeps: (store: T) => readonly [...P] | [...P], selector: (...args: P) => R): R;
+    (): T;
+}
+export type Slice<T extends ISlices> = (
+/**
+ * The setState is used to update the state.
+ */
+set: Store<T>['setState'], 
+/**
+ * The getState is used to get the state.
+ */
+get: Getter<T>, 
+/**
+ * The store is used to store the state.
+ */
+store: Store<T>) => T;
+export type Slices<T extends ISlices, K extends keyof T> = (
+/**
+ * The setState is used to update the state.
+ */
+set: Store<T>['setState'], 
+/**
+ * The getState is used to get the state.
+ */
+get: Getter<T>, 
+/**
+ * The store is used to store the state.
+ */
+store: Store<T>) => T[K];
+export type Middleware<T extends CreateState> = (store: Store<T>) => Store<T>;
+export type SliceState<T extends Record<string, Slice<any>>> = {
+    [K in keyof T]: ReturnType<T[K]>;
+};
+export type StoreOptions<T extends CreateState> = {
+    /**
+     * The name of the store.
+     */
+    name?: string;
+    transport?: Transport;
+    workerType?: 'SharedWorkerInternal' | 'WebWorkerInternal';
+    middlewares?: Middleware<T>[];
+    /**
+     * enable patches
+     */
+    enablePatches?: boolean;
+};
+export type ClientStoreOptions<T extends CreateState> = {
+    /**
+     * The name of the store.
+     */
+    name?: string;
+    middlewares?: Middleware<T>[];
+} & ClientTransportOptions;
+export interface ClientTransportOptions {
+    workerType?: 'WebWorkerClient' | 'SharedWorkerClient';
+    clientTransport?: Transport<any>;
+    worker?: SharedWorker | Worker;
+}
+export type Asyncify<T extends object, D extends true | false> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>> : D extends false ? T[K] : {
+        [P in keyof T[K]]: T[K][P] extends (...args: any[]) => any ? (...args: Parameters<T[K][P]>) => Promise<ReturnType<T[K][P]>> : T[K][P];
+    };
+};
+export type StoreWithAsyncFunction<T extends object, D extends true | false = false> = Store<Asyncify<T, D>> & (() => Asyncify<T, D>);
+export type StoreReturn<T extends object> = Store<T> & ((...args: any[]) => T);
+export type CreateState = ISlices | Record<string, Slice<any>>;
+export type Creator = {
+    <T extends Record<string, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
+    <T extends ISlices>(createState: Slice<T>, options?: StoreOptions<T>): StoreReturn<T>;
+    <T extends Record<string, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
+    <T extends ISlices>(createState: Slice<T>, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+};
+export type ClientTransport = (Transport<{
+    listen: InternalEvents;
+    emit: ExternalEvents;
+}> & {
+    /**
+     * onConnect is called when the transport is connected.
+     */
+    onConnect?: (fn: () => void) => void;
+}) | undefined;
+export type StoreTransport = (Transport<{
+    listen: ExternalEvents;
+    emit: InternalEvents;
+}> & {
+    /**
+     * onConnect is called when the transport is connected.
+     */
+    onConnect?: (fn: () => void) => void;
+}) | undefined;
+export {};

package/dist/declarations/src/wrapStore.d.ts

@@ -0,0 +1,5 @@
+import type { Store, StoreReturn } from "./interface.js";
+/**
+ * wrapStore is a function to wrap the store and return function to get the state with store.
+ */
+export declare const wrapStore: (store: Store<any>, getState?: (...args: any[]) => any) => StoreReturn<any>;

package/package.json

@@ -1,11 +1,51 @@
 {
   "name": "coaction",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "unadlib",
-  "license": "ISC"
+  "version": "0.1.1",
+  "description": "A sleek JavaScript library designed for high-performance and multithreading web apps.",
+  "keywords": [
+    "coaction"
+  ],
+  "authors": [
+    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
+  ],
+  "homepage": "https://github.com/unadlib/coaction/tree/main/packages/core#readme",
+  "license": "MIT",
+  "main": "dist/coaction.cjs.js",
+  "module": "dist/coaction.esm.js",
+  "umd:main": "dist/coaction.umd.min.js",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/coaction.cjs.mjs",
+        "default": "./dist/coaction.cjs.js"
+      },
+      "module": "./dist/coaction.esm.js",
+      "import": "./dist/coaction.cjs.mjs",
+      "default": "./dist/coaction.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/unadlib/coaction.git"
+  },
+  "scripts": {},
+  "bugs": {
+    "url": "https://github.com/unadlib/coaction/issues"
+  },
+  "devDependencies": {},
+  "preconstruct": {
+    "umdName": "Coaction",
+    "entrypoints": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "data-transport": "^4.5.0",
+    "mutative": "^1.1.0"
+  }
 }