plug-code 1.0.1 → 1.0.2

package/README.md

@@ -11,6 +11,6 @@ You are welcome to use Plug&Code in your projects, **personal or commercial**, a
 You can install the framework via npm or yarn:
 
 ```bash
-npm install @alaumo/plug-code
+npm install plug-code
 # or
-yarn add @alaumo/plug-code
+yarn add plug-code

package/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types/plug-code";
+export * from "./types/core/plcAPI";
+export * from "./types/core/plcStore";
+export * from "./types/contexts/pipeline";
+
+export * from "./types/types/api";
+export * from "./types/types/features";
+export * from "./types/types/general";
+export * from "./types/types/pipeline";
+export * from "./types/types/store";

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "plug-code",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
+  "types": "types/src/plug-code.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build:types": "tsc -p tsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -23,6 +25,7 @@
     "react": "^19.2.3"
   },
   "devDependencies": {
-    "@types/react": "^19.2.7"
+    "@types/react": "^19.2.7",
+    "typescript": "^5.4.2"
   }
 }

package/src/core/plcAPI.tsx

@@ -44,7 +44,14 @@ export class PlcAPI<S extends ObjectType> {
         }
     }
 
-    scope<T = any>(key: string & "root") {
+    scope<T = any>(key: string & "root"): {
+        get: () => T;
+        update: (updater: (draft: T) => void) => void;
+        connect: (renderer: (data: T) => React.ReactNode) => React.FC;
+        render: (slotName: string) => React.ReactNode | null;
+        receive: (context?: any) => any;
+        root: PlcAPI<S>;
+    } {
         return {
             get: (): T => this.getData(key),
 
@@ -58,8 +65,8 @@ export class PlcAPI<S extends ObjectType> {
 
             render: (slotName: string) => {
                 return this.connect(key, (localData) => {
-                    return this.pipeline.render(slotName, localData);
-                });
+                    return this.pipeline.render(slotName, localData) as React.ReactNode;
+                }) as any;
             },
 
             receive: (context: any = {}) => {

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "ESNext",
+    "jsx": "react-jsx",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "Node"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/types/contexts/pipeline.d.ts

@@ -0,0 +1,2 @@
+export declare const ScopeContext: import("react").Context<any>;
+export declare const useScopeData: <T>() => T;

package/types/core/plcAPI.d.ts

@@ -0,0 +1,30 @@
+import type { ObjectType } from "../types/general";
+import type { PlcStore } from "./plcStore";
+export declare class PlcAPI<S extends ObjectType> {
+    private store;
+    private pipeline;
+    private substores;
+    private transformers;
+    constructor(store: PlcStore<S>);
+    register(slot: string, node: () => React.ReactNode): void;
+    register<K extends string>(slot: string, node: (data: any) => React.ReactNode, dependencyKey: K): void;
+    scope<T = any>(key: string & "root"): {
+        get: () => T;
+        update: (updater: (draft: T) => void) => void;
+        connect: (renderer: (data: T) => React.ReactNode) => React.FC;
+        render: (slotName: string) => React.ReactNode | null;
+        receive: (context?: any) => any;
+        root: PlcAPI<S>;
+    };
+    connect<T = any>(key: string, renderer: (data: T) => React.ReactNode): React.FC;
+    wrap(slot: string, fn: (next: () => React.ReactNode) => () => React.ReactNode): void;
+    after(slot: string, node: () => React.ReactNode): void;
+    render(slot: string): import("react").ReactNode[] | import("react/jsx-runtime").JSX.Element;
+    invalidate(slot?: string): void;
+    send(id: string, fn: (data: any, context: any) => any, priority: number): void;
+    receive(initialData: any, context?: any): any;
+    getData(key: string): any;
+    subscribe(listener: () => void): () => void;
+    createData<K extends string, T>(key: K, initialState: T): void;
+    update<K extends keyof S>(key: string & "root", updater: (draft: any) => void, slot?: string): void;
+}

package/types/core/plcPipeline.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import type { ObjectType } from "../types/general";
+import type { Slot } from "../types/pipeline";
+import type { PlcStore } from "./plcStore";
+export declare class PlcPipeline<S extends ObjectType> {
+    private slots;
+    private store;
+    private cache;
+    private scheduleQueue;
+    constructor(store: PlcStore<S>);
+    register(slot: string, fn: Slot, priority?: number): void;
+    wrap(slot: string, wrapper: (next: Slot) => Slot, priority?: number): void;
+    render(slot: string, contextData?: any): React.ReactNode[] | import("react/jsx-runtime").JSX.Element;
+    invalidate(slot?: string): void;
+    private regenerateCache;
+}

package/types/core/plcStore.d.ts

@@ -0,0 +1,17 @@
+import { type Draft } from "immer";
+import type { ObjectType } from "../types/general";
+export declare class PlcStore<S extends ObjectType> {
+    private state;
+    private listeners;
+    private batchQueue;
+    private debug;
+    private isBatching;
+    constructor(initial: S, debug: boolean);
+    get<K extends keyof S>(key: K): S[K];
+    getState(): S;
+    set<K extends keyof S>(key: K, value: S[K]): void;
+    batch(updater: (draft: Draft<S>) => void): void;
+    subscribe(listener: () => void): () => void;
+    subscribe<K extends keyof S>(key: K, listener: () => void): () => void;
+    private emit;
+}

package/types/plug-code.d.ts

@@ -0,0 +1,13 @@
+import type { ObjectType } from "./types/general";
+import type { FeatureType } from "./types/features";
+import { PlcAPI } from "./core/plcAPI";
+export declare function createPlugAndCode<S extends ObjectType>(features: FeatureType<S>[]): {
+    useSystemPlc: <T extends object>(initialProps: T) => {
+        api: PlcAPI<{}>;
+        useSelector: <Result>(selector: (state: any) => Result) => Result;
+    };
+    SystemPlcRoot: ({ api, children }: {
+        api: PlcAPI<any>;
+        children?: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+};

package/types/types/api.d.ts

@@ -0,0 +1,5 @@
+export type transformerType = {
+    id: string;
+    priority: number;
+    fn: (data: any, context: any) => any;
+};

package/types/types/features.d.ts

@@ -0,0 +1,6 @@
+import type { PlcAPI } from "../core/plcAPI";
+import type { ObjectType } from "./general";
+export type FeatureType<S extends ObjectType> = {
+    name: string;
+    setup?: (api: PlcAPI<S>) => void | (() => void);
+};

package/types/types/general.d.ts

@@ -0,0 +1 @@
+export type ObjectType = Record<string, any>;

package/types/types/pipeline.d.ts

@@ -0,0 +1,6 @@
+export type Slot = () => React.ReactNode;
+export type ScheduledSlot = {
+    slot: string;
+    fn: Slot;
+    priority: number;
+};

package/types/types/store.d.ts

@@ -0,0 +1,4 @@
+export type Listener<S> = {
+    key?: keyof S;
+    callback: () => void;
+};