plug-code 1.2.0 → 2.0.1

package/dist/core/plcAPI.js

@@ -0,0 +1,472 @@
+import React from "react";
+import { isEqual, shallowCompare } from "./helpers/core";
+import { PlcPipeline } from "./plcPipeline";
+import { LRUCache } from "./plcStore";
+import { Scheduler } from "./plcScheduler";
+import { PlcLayout } from "./ui/plcLayout";
+export class PlcAPI {
+    store;
+    pipeline;
+    scheduler;
+    layout;
+    compiledPipelines = new Map();
+    receiveCache = new LRUCache(300);
+    // Comandos registry
+    commands = new Map();
+    activeDependencyTracker = null;
+    // Loaded features manager
+    loadedFeatures = new Set();
+    constructor(store) {
+        this.store = store;
+        this.pipeline = new PlcPipeline();
+        this.scheduler = new Scheduler();
+        this.layout = new PlcLayout();
+    }
+    // ----------------------
+    // Root store
+    // ----------------------
+    createStore(key, initial) {
+        this.store.createStore(key, initial);
+    }
+    getStore(key) {
+        const value = this.store.getStore(key);
+        this.recordDependency(key, value);
+        return value;
+    }
+    setStore(key, updater, priority = "MED", useTransition = false) {
+        this.scheduler.schedule(() => {
+            if (useTransition) {
+                React.startTransition(() => {
+                    this.store.setStore(key, updater);
+                });
+            }
+            else {
+                this.store.setStore(key, updater);
+            }
+        }, priority);
+    }
+    // ----------------------
+    // Substores
+    // ----------------------
+    createSubstore(substore, key, initial) {
+        this.store.createSubstore(substore, key, initial);
+    }
+    getSubstore(substore, key) {
+        const value = this.store.getSubstore(substore, key);
+        this.recordDependency(`${substore}:${key}`, value);
+        return value;
+    }
+    setSubstore(substore, key, updater, priority = "MED", useTransition = false) {
+        this.scheduler.schedule(() => {
+            if (useTransition) {
+                React.startTransition(() => {
+                    this.store.setSubstore(substore, key, updater);
+                });
+            }
+            else {
+                this.store.setSubstore(substore, key, updater);
+            }
+        }, priority);
+    }
+    // ----------------------
+    // Dependency tracking
+    // ----------------------
+    recordDependency(key, value) {
+        if (this.activeDependencyTracker)
+            this.activeDependencyTracker.set(key, value);
+    }
+    // ----------------------
+    // Transforms
+    // ----------------------
+    makeTransform(channel, id, fn, priority = 0) {
+        const t = { id, priority, fn: (d, c) => fn(d, c) };
+        this.pipeline.registerTransform(channel, t);
+        this.compiledPipelines.delete(channel);
+        this.receiveCache.delete(channel);
+    }
+    async getTransform(channel, initialData, context = {}, opts) {
+        const channelStr = channel;
+        const cached = this.receiveCache.get(channelStr);
+        const equality = opts?.equality ?? 'identity';
+        if (cached) {
+            const sameInput = equality === 'identity' ? cached.input === initialData : isEqual(cached.input, initialData);
+            const sameContext = shallowCompare(cached.contextArgs, context);
+            if (sameInput && sameContext) {
+                let depsChanged = false;
+                for (const [key, lastValue] of cached.dependencies) {
+                    let current;
+                    if (key.includes(":")) {
+                        const [substore, subKey] = key.split(":");
+                        current = this.store.getSubstore(substore, subKey);
+                    }
+                    else {
+                        current = this.store.getStore(key);
+                    }
+                    if (current !== lastValue) {
+                        depsChanged = true;
+                        break;
+                    }
+                }
+                if (!depsChanged)
+                    return cached.result;
+            }
+        }
+        let runner = this.compiledPipelines.get(channelStr);
+        if (!runner) {
+            const compiled = this.pipeline.compilePipeline(channelStr);
+            this.compiledPipelines.set(channelStr, compiled);
+            runner = compiled;
+        }
+        const prevTracker = this.activeDependencyTracker;
+        const currentTracker = new Map();
+        this.activeDependencyTracker = currentTracker;
+        let result;
+        try {
+            result = await this.store.runWithDependencyTracker(currentTracker, async () => {
+                return await runner(initialData, context);
+            });
+        }
+        finally {
+            this.activeDependencyTracker = prevTracker;
+        }
+        this.receiveCache.set(channelStr, {
+            input: initialData,
+            result,
+            dependencies: currentTracker,
+            contextArgs: context
+        });
+        return result;
+    }
+    receive(channel, initialData, context = {}) {
+        const channelStr = channel;
+        const runner = this.compiledPipelines.get(channelStr);
+        if (!runner)
+            throw new Error("[PlcAPI] Pipeline not compiled yet. Use getTransform (async).");
+        const res = runner(initialData, context);
+        if (res && typeof res.then === 'function')
+            throw new Error("[PlcAPI] Pipeline contains async transforms; use getTransform (async).");
+        return res;
+    }
+    // ----------------------
+    // Command System (SOLUCIÓN AQUI)
+    // ----------------------
+    registerCommand(id, fn) {
+        if (this.commands.has(id)) {
+            console.warn(`[PlcAPI] Overwriting command '${id}'`);
+        }
+        this.commands.set(id, fn);
+    }
+    wrapCommand(id, wrapper) {
+        const currentFn = this.commands.get(id);
+        if (!currentFn) {
+            console.error(`[PlcAPI] Cannot wrap '${id}', command does not exist.`);
+            return;
+        }
+        this.commands.set(id, wrapper(currentFn));
+    }
+    async execute(id, payload) {
+        const fn = this.commands.get(id);
+        if (!fn) {
+            throw new Error(`[PlcAPI] Command '${id}' not found.`);
+        }
+        try {
+            return await fn(payload);
+        }
+        catch (error) {
+            console.error(`[PlcAPI] Error executing '${id}':`, error);
+            throw error;
+        }
+    }
+    // ----------------------
+    // Derives
+    // ----------------------
+    deriveStore(outputKey, outputSlot, dependencies, calculator) {
+        let lastInputs = null;
+        let lastOutput;
+        let isComputing = false;
+        let scheduled = false;
+        const scheduleUpdate = () => {
+            if (scheduled)
+                return;
+            scheduled = true;
+            Promise.resolve().then(() => {
+                scheduled = false;
+                this.store.batch(runCompute);
+            });
+        };
+        const runCompute = () => {
+            if (isComputing)
+                return;
+            isComputing = true;
+            try {
+                const inputs = dependencies.map(dep => this.getStore(dep));
+                if (lastInputs && inputs.every((v, i) => isEqual(v, lastInputs[i])))
+                    return;
+                const result = calculator(...inputs);
+                if (isEqual(result, lastOutput)) {
+                    lastInputs = inputs;
+                    return;
+                }
+                lastInputs = inputs;
+                lastOutput = result;
+                this.setStore(outputSlot, (draft) => {
+                    if (!draft)
+                        return { [String(outputKey)]: result };
+                    draft[String(outputKey)] = result;
+                    return;
+                });
+            }
+            finally {
+                isComputing = false;
+            }
+        };
+        runCompute();
+        const unsubscribers = dependencies.map(dep => this.store.subscribe(dep, scheduleUpdate));
+        return {
+            getValue: () => lastOutput,
+            trigger: scheduleUpdate,
+            dispose: () => unsubscribers.forEach(u => u())
+        };
+    }
+    deriveSubstore(substore, outputKey, outputSlot, dependencies, calculator) {
+        let lastInputs = null;
+        let lastOutput;
+        let isComputing = false;
+        let scheduled = false;
+        const scheduleUpdate = () => {
+            if (scheduled)
+                return;
+            scheduled = true;
+            Promise.resolve().then(() => {
+                scheduled = false;
+                this.store.batch(runCompute);
+            });
+        };
+        const runCompute = () => {
+            if (isComputing)
+                return;
+            isComputing = true;
+            try {
+                const inputs = dependencies.map(dep => this.getSubstore(substore, dep));
+                if (lastInputs && inputs.every((v, i) => isEqual(v, lastInputs[i])))
+                    return;
+                const result = calculator(...inputs);
+                if (isEqual(result, lastOutput)) {
+                    lastInputs = inputs;
+                    return;
+                }
+                lastInputs = inputs;
+                lastOutput = result;
+                this.setSubstore(substore, outputSlot, (draft) => {
+                    if (!draft)
+                        return { [String(outputKey)]: result };
+                    draft[String(outputKey)] = result;
+                    return;
+                });
+            }
+            finally {
+                isComputing = false;
+            }
+        };
+        runCompute();
+        const unsubscribers = dependencies.map(dep => this.store.subscribe(`${substore}:${dep}`, scheduleUpdate));
+        return {
+            getValue: () => lastOutput,
+            trigger: scheduleUpdate,
+            dispose: () => unsubscribers.forEach(u => u())
+        };
+    }
+    // ----------------------
+    // Watchers
+    // ----------------------
+    _triggerVersion = new Map();
+    bumpVersion(key) {
+        this._triggerVersion.set(key, (this._triggerVersion.get(key) || 0) + 1);
+    }
+    watch(key, selector, callback) {
+        if (key.includes(":")) {
+            const [feature, subKey] = key.split(":");
+            return this.watchSubstore(feature, subKey, selector, callback);
+        }
+        return this.watchStore(key, selector, callback);
+    }
+    watchStore(storeKey, selector, callback) {
+        let prevVersion = this._triggerVersion.get(storeKey) || 0;
+        let prevValue = selector(this.getStore(storeKey));
+        const handleChange = () => {
+            const version = this._triggerVersion.get(storeKey) || 0;
+            const newValue = selector(this.getStore(storeKey));
+            if (version !== prevVersion || !isEqual(newValue, prevValue)) {
+                const old = prevValue;
+                prevValue = newValue;
+                prevVersion = version;
+                callback(newValue, old);
+            }
+        };
+        return this.store.subscribe(storeKey, handleChange);
+    }
+    watchSubstore(substore, key, selector, callback) {
+        const storeKey = `${substore}:${key}`;
+        let prevVersion = this._triggerVersion.get(storeKey) || 0;
+        let prevValue = selector(this.getSubstore(substore, key));
+        const handleChange = () => {
+            const version = this._triggerVersion.get(storeKey) || 0;
+            const newValue = selector(this.getSubstore(substore, key));
+            if (version !== prevVersion || !isEqual(newValue, prevValue)) {
+                const old = prevValue;
+                prevValue = newValue;
+                prevVersion = version;
+                callback(newValue, old);
+            }
+        };
+        return this.store.subscribe(storeKey, handleChange);
+    }
+    watchAllStores(definitions, callback) {
+        const getCombinedState = () => {
+            let result = {};
+            for (const def of definitions) {
+                const slice = def.substore
+                    ? def.selector(this.getSubstore(def.substore, def.store))
+                    : def.selector(this.getStore(def.store));
+                result = { ...result, ...slice };
+            }
+            return result;
+        };
+        let prevCombined = getCombinedState();
+        const handleChange = () => {
+            const currentCombined = getCombinedState();
+            if (!isEqual(prevCombined, currentCombined)) {
+                const old = prevCombined;
+                prevCombined = currentCombined;
+                callback(currentCombined, old);
+            }
+        };
+        const unsubscribers = definitions.map(def => {
+            const key = def.substore ? `${def.substore}:${def.store}` : def.store;
+            return this.store.subscribe(key, handleChange);
+        });
+        return () => unsubscribers.forEach(u => u());
+    }
+    // ----------------------
+    // Redraw
+    // ----------------------
+    redraw(keyOrSlot) {
+        this.bumpVersion(keyOrSlot);
+        this.layout.invalidate(keyOrSlot);
+        const currentRoot = this.store.getStore(keyOrSlot);
+        if (currentRoot !== undefined) {
+            this.store.setStore(keyOrSlot, (d) => d);
+        }
+    }
+    // ----------------------
+    // UI
+    // ----------------------
+    register(slot, id, componentFn, priority = 0, keepAlive = false) {
+        this.layout.register(slot, id, componentFn, priority, keepAlive);
+    }
+    wrap(slot, wrapper) {
+        this.layout.wrap(slot, wrapper);
+    }
+    after(slot, targetId, newId, componentFn) {
+        const targetPriority = this.layout.getPriority(slot, targetId);
+        let newPriority;
+        if (targetPriority !== undefined) {
+            newPriority = targetPriority - 1;
+        }
+        else {
+            console.warn(`[PlcAPI] 'after': Target '${targetId}' not found in slot '${slot}'. Registering '${newId}' at the end.`);
+            newPriority = -999;
+        }
+        this.layout.register(slot, newId, componentFn, newPriority);
+    }
+    render(slot, props) {
+        return this.layout.render(slot, props);
+    }
+    markVirtual(slot, config) {
+        this.layout.markVirtual(slot, config);
+    }
+    connect(renderFn, dependencies) {
+        return (props) => {
+            const [, forceUpdate] = React.useReducer(x => x + 1, 0);
+            const prevValuesRef = React.useRef(new Map());
+            React.useEffect(() => {
+                const unsubscribers = [];
+                dependencies.forEach(dep => {
+                    const keyStr = typeof dep === 'string' ? dep : dep.store;
+                    const getValue = () => typeof dep === 'string'
+                        ? this.getStore(dep)
+                        : dep.store.includes(":")
+                            ? this.store.getSubstore(...dep.store.split(":"))
+                            : this.getStore(dep.store);
+                    prevValuesRef.current.set(keyStr, getValue());
+                    unsubscribers.push(this.store.subscribe(keyStr, () => {
+                        const newVal = getValue();
+                        if (!isEqual(prevValuesRef.current.get(keyStr), newVal)) {
+                            prevValuesRef.current.set(keyStr, newVal);
+                            forceUpdate();
+                        }
+                    }));
+                });
+                return () => unsubscribers.forEach(u => u());
+            }, []);
+            return renderFn(props);
+        };
+    }
+    // ----------------------
+    // Modules
+    // ----------------------
+    registerModule(manifest) {
+        if (this.loadedFeatures.has(manifest.name))
+            return;
+        if (manifest.state) {
+            Object.entries(manifest.state).forEach(([key, val]) => {
+                this.createSubstore(manifest.name, key, val);
+            });
+        }
+        if (manifest.commands) {
+            Object.entries(manifest.commands).forEach(([cmdId, fn]) => {
+                const fullId = cmdId.includes(":") ? cmdId : `${manifest.name}:${cmdId}`;
+                this.commands.set(fullId, fn);
+            });
+        }
+        if (manifest.slots) {
+            Object.entries(manifest.slots).forEach(([slotName, components]) => {
+                components.forEach(comp => {
+                    this.register(slotName, comp.id, comp.component, comp.priority, comp.keepAlive);
+                });
+            });
+        }
+        if (manifest.onLoad) {
+            manifest.onLoad(this);
+        }
+        this.loadedFeatures.add(manifest.name);
+        console.debug(`[PlcAPI] Feature loaded: ${manifest.name}`);
+    }
+    async loadFeature(importer) {
+        try {
+            const module = await importer();
+            this.registerModule(module.default);
+        }
+        catch (err) {
+            console.error(`[PlcAPI] Failed to load feature`, err);
+            throw err;
+        }
+    }
+    // ----------------------
+    // Selector
+    // ----------------------
+    createSelector(extractor, calculator) {
+        let lastArgs = null;
+        let lastResult = null;
+        return (state) => {
+            const args = extractor(state);
+            if (lastArgs && args.length === lastArgs.length && args.every((val, i) => val === lastArgs[i])) {
+                return lastResult;
+            }
+            const result = calculator(...args);
+            lastArgs = args;
+            lastResult = result;
+            return result;
+        };
+    }
+}

package/dist/core/plcPipeline.d.ts

@@ -0,0 +1,8 @@
+import { transformerType } from "../types/core/api";
+export declare class PlcPipeline {
+    private transforms;
+    registerTransform(channel: string, t: transformerType): void;
+    removeTransform(channel: string, id: string): void;
+    getTransforms(channel: string): transformerType[];
+    compilePipeline(channel: string): (input: any, ctx: any) => Promise<any>;
+}

package/dist/core/plcPipeline.js

@@ -0,0 +1,35 @@
+export class PlcPipeline {
+    transforms = new Map();
+    registerTransform(channel, t) {
+        if (!this.transforms.has(channel))
+            this.transforms.set(channel, []);
+        const list = this.transforms.get(channel);
+        const idx = list.findIndex(x => x.id === t.id);
+        if (idx >= 0)
+            list[idx] = t;
+        else
+            list.push(t);
+        list.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    }
+    removeTransform(channel, id) {
+        const list = this.transforms.get(channel);
+        if (!list)
+            return;
+        const idx = list.findIndex(x => x.id === id);
+        if (idx >= 0)
+            list.splice(idx, 1);
+    }
+    getTransforms(channel) {
+        return this.transforms.get(channel) || [];
+    }
+    compilePipeline(channel) {
+        const list = this.getTransforms(channel);
+        return async (input, ctx) => {
+            let data = input;
+            for (const t of list) {
+                data = await t.fn(data, ctx);
+            }
+            return data;
+        };
+    }
+}

package/dist/core/plcScheduler.d.ts

@@ -0,0 +1,7 @@
+export type Priority = "HIGH" | "MED" | "LOW";
+export declare class Scheduler {
+    private isFlushing;
+    private queue;
+    schedule(fn: () => void, priority?: Priority): void;
+    private flush;
+}

package/dist/core/plcScheduler.js

@@ -0,0 +1,22 @@
+export class Scheduler {
+    isFlushing = false;
+    queue = new Map([
+        ["HIGH", new Set()],
+        ["MED", new Set()],
+        ["LOW", new Set()],
+    ]);
+    schedule(fn, priority = "MED") {
+        this.queue.get(priority).add(fn);
+        if (!this.isFlushing)
+            this.flush();
+    }
+    flush() {
+        this.isFlushing = true;
+        for (const level of ["HIGH", "MED", "LOW"]) {
+            const set = this.queue.get(level);
+            set.forEach(fn => fn());
+            set.clear();
+        }
+        this.isFlushing = false;
+    }
+}

package/dist/core/plcStore.d.ts

@@ -0,0 +1,33 @@
+import { Draft } from "immer";
+export type Listener = () => void;
+export type keyListenerMap = Map<string, Set<Listener>>;
+export declare class PlcStore {
+    private storeData;
+    private substoresData;
+    private subscriptions;
+    private isBatching;
+    private dirtyKeys;
+    private activeDependencyTracker;
+    createStore<K extends string, T>(key: K, initial: T): void;
+    getStore(key: string): any;
+    setStore<T>(key: string, updater: T | ((draft: Draft<T>) => void | T)): void;
+    createSubstore<K extends string, T>(substore: string, key: K, initial: T): void;
+    getSubstore(substore: string, key: string): any;
+    setSubstore<T>(substore: string, key: string, updater: T | ((draft: Draft<T>) => void | T)): void;
+    protected recordDependency(key: string, value: any): void;
+    runWithDependencyTracker<T>(tracker: Map<string, any> | null, fn: () => T | Promise<T>): Promise<T>;
+    batch(fn: () => void): void;
+    subscribe(key: string, listener: Listener): () => void;
+    private markDirty;
+    private flush;
+    private notify;
+}
+export declare class LRUCache<K, V> {
+    private maxEntries;
+    private map;
+    constructor(maxEntries?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    clear(): void;
+}