@wooksjs/event-core 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# @wooksjs/event-core
+
+**!!! This is work-in-progress library, breaking changes are expected !!!**
+
+<p align="center">
+<img src="../../logo.png" width="128px"><br>
+<a  href="https://github.com/prostojs/wooks/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" />
+</a>
+</p>
+
+Core functionality of wooks context

package/dist/index.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+const banner = () => `[${"@wooksjs/event-core"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function attachHook(target, opts, name) {
+    Object.defineProperty(target, name || 'value', {
+        get: opts.get,
+        set: opts.set,
+    });
+    return target;
+}
+
+let currentContext = null;
+/**
+ * Create a new event context
+ *
+ * @param data
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function createEventContext(data) {
+    const newContext = Object.assign({}, data);
+    currentContext = newContext;
+    return _getCtxHelpers(newContext);
+}
+/**
+ * Use existing event context
+ *
+ * !Must be called syncronously while context is reachable
+ *
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function useEventContext(expectedTypes) {
+    var _a;
+    if (!currentContext) {
+        throw panic('Event context does not exist. Use event context synchronously within the runtime of the event.');
+    }
+    const cc = currentContext;
+    if (expectedTypes || typeof expectedTypes === 'string') {
+        const type = (_a = cc.event) === null || _a === void 0 ? void 0 : _a.type;
+        const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
+        if (!types.includes(type))
+            panic(`Event context type mismatch: expected ${types.map(t => `"${t}"`).join(', ')}, received "${type}"`);
+    }
+    return _getCtxHelpers(cc);
+}
+function _getCtxHelpers(cc) {
+    /**
+     * Hook to an event store property
+     *
+     * @param key store property key
+     * @returns a hook { value: <prop value>, hook: (key2: keyof <prop value>) => { value: <nested prop value> }, ... }
+     */
+    function store(key) {
+        const obj = {
+            value: null,
+            hook,
+            init,
+            set: setNested,
+            get: getNested,
+            has: hasNested,
+            del: delNested,
+            entries,
+            clear,
+        };
+        attachHook(obj, {
+            set: v => set(key, v),
+            get: () => get(key),
+        });
+        function init(key2, getter) {
+            if (hasNested(key2))
+                return getNested(key2);
+            return setNested(key2, getter());
+        }
+        function hook(key2) {
+            const obj = {
+                value: null,
+                isDefined: null,
+            };
+            attachHook(obj, {
+                set: v => setNested(key2, v),
+                get: () => getNested(key2),
+            });
+            attachHook(obj, {
+                get: () => hasNested(key2),
+            }, 'isDefined');
+            return obj;
+        }
+        function setNested(key2, v) {
+            if (typeof obj.value === 'undefined') {
+                obj.value = {};
+            }
+            obj.value[key2] = v;
+            return v;
+        }
+        function delNested(key2) {
+            setNested(key2, undefined);
+        }
+        function getNested(key2) { return (obj.value || {})[key2]; }
+        function hasNested(key2) { return typeof (obj.value || {})[key2] !== 'undefined'; }
+        function entries() { return Object.entries((obj.value || {})); }
+        function clear() { obj.value = {}; }
+        return obj;
+    }
+    /**
+     * Get event context object
+     *
+     * @returns whole context object
+     */
+    function getCtx() { return cc; }
+    /**
+     * Get value of event store property
+     *
+     * @param key property name
+     * @returns value of property by name
+     */
+    function get(key) { return getCtx()[key]; }
+    /**
+     * Set value of event store property
+     *
+     * @param key property name
+     * @param v property value
+     */
+    function set(key, v) {
+        (getCtx())[key] = v;
+    }
+    return {
+        getCtx,
+        restoreCtx: () => currentContext = cc,
+        clearCtx: () => cc === currentContext ? currentContext = null : null,
+        store,
+        getStore: get,
+        setStore: set,
+    };
+}
+
+function useRouteParams() {
+    const { store } = useEventContext();
+    const params = (store('routeParams').value || {});
+    function get(name) {
+        return params[name];
+    }
+    return {
+        params,
+        get,
+    };
+}
+
+exports.attachHook = attachHook;
+exports.createEventContext = createEventContext;
+exports.useEventContext = useEventContext;
+exports.useRouteParams = useRouteParams;

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+export declare function attachHook<V = unknown, T extends (object | Function) = object, P extends PropertyKey = 'value'>(target: T, opts: {
+    get: () => V | undefined;
+    set?: (value: V) => void;
+}, name?: P): T & { [name in P]?: V | undefined; };
+
+/**
+ * Create a new event context
+ *
+ * @param data
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+export declare function createEventContext<S extends TGenericContextStore>(data: S): {
+    getCtx: () => S;
+    restoreCtx: () => S;
+    clearCtx: () => null;
+    store: <K extends keyof S>(key: K) => {
+        value: S[K];
+        hook: <K2 extends keyof Required<S>[K]>(key2: K2) => {
+            value: Required<S>[K][K2];
+            isDefined: boolean;
+        };
+        init: <K2_1 extends keyof Required<S>[K]>(key2: K2_1, getter: () => Required<Required<S>[K]>[K2_1]) => Required<Required<S>[K]>[K2_1];
+        set: <K2_2 extends keyof Required<S>[K]>(key2: K2_2, v: Required<S[K]>[K2_2]) => Required<S[K]>[K2_2];
+        get: <K2_3 extends keyof Required<S>[K]>(key2: K2_3) => Required<S>[K][K2_3];
+        has: <K2_4 extends keyof Required<S>[K]>(key2: K2_4) => boolean;
+        del: <K2_5 extends keyof Required<S>[K]>(key2: K2_5) => void;
+        entries: () => [string, unknown][];
+        clear: () => void;
+    };
+    getStore: <K_1 extends keyof S>(key: K_1) => S[K_1];
+    setStore: <K_2 extends keyof S>(key: K_2, v: S[K_2]) => void;
+};
+
+export declare type TGenericContextStore<E extends TGenericEvent = TGenericEvent> = {
+    event: E;
+    routeParams?: Record<string, string | string[]>;
+};
+
+export declare interface TGenericEvent {
+    type: string;
+}
+
+/**
+ * Use existing event context
+ *
+ * !Must be called syncronously while context is reachable
+ *
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+export declare function useEventContext<S extends TGenericContextStore>(expectedTypes?: string | string[]): {
+    getCtx: () => S;
+    restoreCtx: () => S;
+    clearCtx: () => null;
+    store: <K extends keyof S>(key: K) => {
+        value: S[K];
+        hook: <K2 extends keyof Required<S>[K]>(key2: K2) => {
+            value: Required<S>[K][K2];
+            isDefined: boolean;
+        };
+        init: <K2_1 extends keyof Required<S>[K]>(key2: K2_1, getter: () => Required<Required<S>[K]>[K2_1]) => Required<Required<S>[K]>[K2_1];
+        set: <K2_2 extends keyof Required<S>[K]>(key2: K2_2, v: Required<S[K]>[K2_2]) => Required<S[K]>[K2_2];
+        get: <K2_3 extends keyof Required<S>[K]>(key2: K2_3) => Required<S>[K][K2_3];
+        has: <K2_4 extends keyof Required<S>[K]>(key2: K2_4) => boolean;
+        del: <K2_5 extends keyof Required<S>[K]>(key2: K2_5) => void;
+        entries: () => [string, unknown][];
+        clear: () => void;
+    };
+    getStore: <K_1 extends keyof S>(key: K_1) => S[K_1];
+    setStore: <K_2 extends keyof S>(key: K_2, v: S[K_2]) => void;
+};
+
+export declare function useRouteParams<T extends object = Record<string, string | string[]>>(): {
+    params: T;
+    get: <K extends keyof T>(name: K) => T[K];
+};
+
+export { }

package/dist/index.mjs

@@ -0,0 +1,157 @@
+const banner = () => `[${"@wooksjs/event-core"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function attachHook(target, opts, name) {
+    Object.defineProperty(target, name || 'value', {
+        get: opts.get,
+        set: opts.set,
+    });
+    return target;
+}
+
+let currentContext = null;
+/**
+ * Create a new event context
+ *
+ * @param data
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function createEventContext(data) {
+    const newContext = Object.assign({}, data);
+    currentContext = newContext;
+    return _getCtxHelpers(newContext);
+}
+/**
+ * Use existing event context
+ *
+ * !Must be called syncronously while context is reachable
+ *
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function useEventContext(expectedTypes) {
+    var _a;
+    if (!currentContext) {
+        throw panic('Event context does not exist. Use event context synchronously within the runtime of the event.');
+    }
+    const cc = currentContext;
+    if (expectedTypes || typeof expectedTypes === 'string') {
+        const type = (_a = cc.event) === null || _a === void 0 ? void 0 : _a.type;
+        const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
+        if (!types.includes(type))
+            panic(`Event context type mismatch: expected ${types.map(t => `"${t}"`).join(', ')}, received "${type}"`);
+    }
+    return _getCtxHelpers(cc);
+}
+function _getCtxHelpers(cc) {
+    /**
+     * Hook to an event store property
+     *
+     * @param key store property key
+     * @returns a hook { value: <prop value>, hook: (key2: keyof <prop value>) => { value: <nested prop value> }, ... }
+     */
+    function store(key) {
+        const obj = {
+            value: null,
+            hook,
+            init,
+            set: setNested,
+            get: getNested,
+            has: hasNested,
+            del: delNested,
+            entries,
+            clear,
+        };
+        attachHook(obj, {
+            set: v => set(key, v),
+            get: () => get(key),
+        });
+        function init(key2, getter) {
+            if (hasNested(key2))
+                return getNested(key2);
+            return setNested(key2, getter());
+        }
+        function hook(key2) {
+            const obj = {
+                value: null,
+                isDefined: null,
+            };
+            attachHook(obj, {
+                set: v => setNested(key2, v),
+                get: () => getNested(key2),
+            });
+            attachHook(obj, {
+                get: () => hasNested(key2),
+            }, 'isDefined');
+            return obj;
+        }
+        function setNested(key2, v) {
+            if (typeof obj.value === 'undefined') {
+                obj.value = {};
+            }
+            obj.value[key2] = v;
+            return v;
+        }
+        function delNested(key2) {
+            setNested(key2, undefined);
+        }
+        function getNested(key2) { return (obj.value || {})[key2]; }
+        function hasNested(key2) { return typeof (obj.value || {})[key2] !== 'undefined'; }
+        function entries() { return Object.entries((obj.value || {})); }
+        function clear() { obj.value = {}; }
+        return obj;
+    }
+    /**
+     * Get event context object
+     *
+     * @returns whole context object
+     */
+    function getCtx() { return cc; }
+    /**
+     * Get value of event store property
+     *
+     * @param key property name
+     * @returns value of property by name
+     */
+    function get(key) { return getCtx()[key]; }
+    /**
+     * Set value of event store property
+     *
+     * @param key property name
+     * @param v property value
+     */
+    function set(key, v) {
+        (getCtx())[key] = v;
+    }
+    return {
+        getCtx,
+        restoreCtx: () => currentContext = cc,
+        clearCtx: () => cc === currentContext ? currentContext = null : null,
+        store,
+        getStore: get,
+        setStore: set,
+    };
+}
+
+function useRouteParams() {
+    const { store } = useEventContext();
+    const params = (store('routeParams').value || {});
+    function get(name) {
+        return params[name];
+    }
+    return {
+        params,
+        get,
+    };
+}
+
+export { attachHook, createEventContext, useEventContext, useRouteParams };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@wooksjs/event-core",
+  "version": "0.1.0",
+  "description": "@wooksjs/event-core",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wooksjs/wooksjs.git",
+    "directory": "packages/event-core"
+  },
+  "keywords": [
+    "http",
+    "wooks",
+    "composables",
+    "web",
+    "framework",
+    "app",
+    "api",
+    "rest",
+    "restful",
+    "prostojs"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wooksjs/wooksjs/issues"
+  },
+  "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/event-core#readme"
+}