@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

package/dist/vue/state/State.js

@@ -0,0 +1,267 @@
+import { debounce } from 'lodash-es';
+import { NonPersistentDriver } from '../../persistenceDrivers';
+import { computed, ref, watch, reactive } from 'vue';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function getNestedValue(root, pathParts) {
+    let current = root;
+    for (const part of pathParts) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export class State {
+    constructor(initial, options) {
+        this._stateProxy = null;
+        this._watchStopFunctions = new Map();
+        this._resetHandlers = new Map();
+        this._watchIdCounter = 0;
+        this._initial = initial;
+        this._persist = !!(options === null || options === void 0 ? void 0 : options.persist);
+        const className = this.constructor.name;
+        this._persistKey = className + ((options === null || options === void 0 ? void 0 : options.persistSuffix) ? `_${options.persistSuffix}` : '');
+        this._driver = this.getPersistenceDriver();
+        let loaded = null;
+        if (this._persist) {
+            loaded = this._driver.get(this._persistKey);
+            if (loaded) {
+                const initialKeys = Object.keys(initial).sort();
+                const loadedKeys = Object.keys(loaded).sort();
+                const sameKeys = initialKeys.length === loadedKeys.length && initialKeys.every((k, i) => k === loadedKeys[i]);
+                if (!sameKeys) {
+                    this._driver.remove(this._persistKey);
+                    loaded = null;
+                }
+            }
+        }
+        const base = loaded !== null && loaded !== void 0 ? loaded : initial;
+        this.properties = {};
+        const keys = Object.keys(base);
+        for (const k of keys) {
+            let value = base[k];
+            value = this.wrapReactive(value);
+            const _ref = ref(value);
+            this.properties[k] = computed({
+                get: () => _ref.value,
+                set: (val) => {
+                    _ref.value = this.wrapReactive(val);
+                    if (this._persist) {
+                        this._driver.set(this._persistKey, this.export());
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Safe deep clone that preserves types
+     */
+    deepClone(value) {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value !== 'object')
+            return value;
+        return JSON.parse(JSON.stringify(value));
+    }
+    /**
+     * Ensure objects/arrays are cloned and wrapped in Vue reactivity.
+     */
+    wrapReactive(value) {
+        if (value && typeof value === 'object') {
+            return reactive(this.deepClone(value));
+        }
+        return value;
+    }
+    /**
+     * Get a proxy to the state that allows direct property access and setting
+     * without using .value
+     */
+    get state() {
+        if (!this._stateProxy) {
+            this._stateProxy = new Proxy({}, {
+                get: (_, prop) => {
+                    if (typeof prop === 'symbol' || prop === 'toJSON') {
+                        return undefined;
+                    }
+                    const key = prop;
+                    if (key in this.properties) {
+                        return this.properties[key].value;
+                    }
+                    return undefined;
+                },
+                set: (_, prop, value) => {
+                    if (typeof prop === 'symbol') {
+                        return false;
+                    }
+                    const key = prop;
+                    if (key in this.properties) {
+                        this.properties[key].value = value;
+                    }
+                    return true;
+                }
+            });
+        }
+        return this._stateProxy;
+    }
+    subscribe(paths, handler, options) {
+        const stopFunctions = [];
+        const resetHandlers = [];
+        if (Array.isArray(paths)) {
+            for (const path of paths) {
+                const pathHandler = () => {
+                    ;
+                    handler(path, this.export());
+                };
+                if (options === null || options === void 0 ? void 0 : options.executeOnReset) {
+                    resetHandlers.push(pathHandler);
+                }
+                const stop = this.setupWatcher(path, pathHandler, options);
+                stopFunctions.push(stop);
+            }
+        }
+        else {
+            const pathHandler = handler;
+            if (options === null || options === void 0 ? void 0 : options.executeOnReset) {
+                resetHandlers.push(() => pathHandler(undefined, undefined));
+            }
+            const stop = this.setupWatcher(paths, pathHandler, options);
+            stopFunctions.push(stop);
+        }
+        if (resetHandlers.length > 0) {
+            const resetId = Math.random().toString(36);
+            this._resetHandlers.set(resetId, resetHandlers);
+            stopFunctions.push(() => {
+                this._resetHandlers.delete(resetId);
+            });
+        }
+        return () => stopFunctions.forEach((stop) => stop());
+    }
+    /**
+     * Internal method to set up a watcher for a specific path
+     */
+    setupWatcher(path, handler, options) {
+        const pathParts = path.split('.');
+        const debouncedHandler = (options === null || options === void 0 ? void 0 : options.debounce) && options.debounce > 0 ? debounce(handler, options.debounce) : undefined;
+        const effectiveHandler = debouncedHandler || handler;
+        if (pathParts.length === 1 && path in this.properties) {
+            const key = path;
+            const stopWatch = watch(() => this.properties[key].value, (newVal, oldVal) => {
+                if (!this.isEqual(newVal, oldVal)) {
+                    effectiveHandler(newVal, oldVal);
+                }
+            }, { deep: true });
+            const watchId = `watch:${this._watchIdCounter++}`;
+            this._watchStopFunctions.set(watchId, stopWatch);
+            return () => {
+                if (this._watchStopFunctions.has(watchId)) {
+                    this._watchStopFunctions.get(watchId)();
+                    this._watchStopFunctions.delete(watchId);
+                }
+            };
+        }
+        const topLevelKey = pathParts[0];
+        if (topLevelKey in this.properties) {
+            const getter = () => {
+                const root = this.properties[topLevelKey].value;
+                return getNestedValue(root, pathParts.slice(1));
+            };
+            const stopWatch = watch(getter, (newVal, oldVal) => {
+                if (!this.isEqual(newVal, oldVal)) {
+                    effectiveHandler(newVal, oldVal);
+                }
+            }, { deep: true });
+            const watchId = `watch:${this._watchIdCounter++}`;
+            this._watchStopFunctions.set(watchId, stopWatch);
+            return () => {
+                if (this._watchStopFunctions.has(watchId)) {
+                    this._watchStopFunctions.get(watchId)();
+                    this._watchStopFunctions.delete(watchId);
+                }
+            };
+        }
+        return () => { };
+    }
+    /**
+     * Simple deep equality check
+     */
+    isEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a === null || b === null)
+            return false;
+        if (a === undefined || b === undefined)
+            return false;
+        if (typeof a !== typeof b)
+            return false;
+        if (typeof a === 'object' && typeof b === 'object') {
+            const aArray = Array.isArray(a);
+            const bArray = Array.isArray(b);
+            if (aArray !== bArray)
+                return false;
+            if (aArray && bArray) {
+                const arrayA = a;
+                const arrayB = b;
+                if (arrayA.length !== arrayB.length)
+                    return false;
+                return arrayA.every((val, i) => this.isEqual(val, arrayB[i]));
+            }
+            const objA = a;
+            const objB = b;
+            const keysA = Object.keys(objA).sort();
+            const keysB = Object.keys(objB).sort();
+            if (keysA.length !== keysB.length)
+                return false;
+            if (!keysA.every((k, i) => k === keysB[i]))
+                return false;
+            return keysA.every((k) => this.isEqual(objA[k], objB[k]));
+        }
+        return false;
+    }
+    getPersistenceDriver() {
+        return new NonPersistentDriver();
+    }
+    export() {
+        const out = {};
+        for (const k in this.properties) {
+            const key = k;
+            out[key] = this.deepClone(this.properties[key].value);
+        }
+        return out;
+    }
+    import(data) {
+        for (const k in data) {
+            if (k in this.properties) {
+                const key = k;
+                this.properties[key].value = data[key];
+            }
+        }
+        if (this._persist) {
+            this._driver.set(this._persistKey, this.export());
+        }
+    }
+    reset() {
+        this.import(this._initial);
+        for (const handlers of this._resetHandlers.values()) {
+            for (const handler of handlers) {
+                handler();
+            }
+        }
+    }
+    get persistKey() {
+        return this._persistKey;
+    }
+    /**
+     * Clean up all watchers when the state is no longer needed
+     */
+    destroy() {
+        for (const stopFn of this._watchStopFunctions.values()) {
+            stopFn();
+        }
+        this._watchStopFunctions.clear();
+        this._resetHandlers.clear();
+        this._stateProxy = null;
+    }
+}

package/dist/vue/state/index.d.ts

@@ -0,0 +1,2 @@
+import { State } from './State';
+export { State };

package/dist/vue/state/index.js

@@ -0,0 +1,2 @@
+import { State } from './State';
+export { State };

package/package.json

@@ -1,30 +1,92 @@
 {
   "name": "@blueprint-ts/core",
-  "version": "4.1.0-beta.1",
+  "version": "4.1.0-beta.3",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "exports": {
-    "./pagination": "./src/pagination/index.ts",
-    "./support": "./src/support/index.ts",
-    "./requests": "./src/requests/index.ts",
-    "./bulkRequests": "./src/bulkRequests/index.ts",
-    "./persistenceDrivers": "./src/persistenceDrivers/index.ts",
-    "./requests/exceptions": "./src/requests/exceptions/index.ts",
-    "./laravel/requests": "./src/laravel/requests/index.ts",
-    "./laravel/pagination": "./src/laravel/pagination/index.ts",
-    "./vue": "./src/vue/index.ts",
-    "./vue/forms": "./src/vue/forms/index.ts",
-    "./vue/forms/validation": "./src/vue/forms/validation/index.ts",
-    "./vue/requests": "./src/vue/requests/index.ts",
-    "./vue/router/routeResourceBinding": "./src/vue/router/routeResourceBinding/index.ts",
-    "./vue/state": "./src/vue/state/index.ts"
+    "./pagination": {
+      "types": "./dist/pagination/index.d.ts",
+      "import": "./dist/pagination/index.js",
+      "default": "./dist/pagination/index.js"
+    },
+    "./support": {
+      "types": "./dist/support/index.d.ts",
+      "import": "./dist/support/index.js",
+      "default": "./dist/support/index.js"
+    },
+    "./requests": {
+      "types": "./dist/requests/index.d.ts",
+      "import": "./dist/requests/index.js",
+      "default": "./dist/requests/index.js"
+    },
+    "./bulkRequests": {
+      "types": "./dist/bulkRequests/index.d.ts",
+      "import": "./dist/bulkRequests/index.js",
+      "default": "./dist/bulkRequests/index.js"
+    },
+    "./persistenceDrivers": {
+      "types": "./dist/persistenceDrivers/index.d.ts",
+      "import": "./dist/persistenceDrivers/index.js",
+      "default": "./dist/persistenceDrivers/index.js"
+    },
+    "./requests/exceptions": {
+      "types": "./dist/requests/exceptions/index.d.ts",
+      "import": "./dist/requests/exceptions/index.js",
+      "default": "./dist/requests/exceptions/index.js"
+    },
+    "./laravel/requests": {
+      "types": "./dist/laravel/requests/index.d.ts",
+      "import": "./dist/laravel/requests/index.js",
+      "default": "./dist/laravel/requests/index.js"
+    },
+    "./laravel/pagination": {
+      "types": "./dist/laravel/pagination/index.d.ts",
+      "import": "./dist/laravel/pagination/index.js",
+      "default": "./dist/laravel/pagination/index.js"
+    },
+    "./vue": {
+      "types": "./dist/vue/index.d.ts",
+      "import": "./dist/vue/index.js",
+      "default": "./dist/vue/index.js"
+    },
+    "./vue/forms": {
+      "types": "./dist/vue/forms/index.d.ts",
+      "import": "./dist/vue/forms/index.js",
+      "default": "./dist/vue/forms/index.js"
+    },
+    "./vue/forms/validation": {
+      "types": "./dist/vue/forms/validation/index.d.ts",
+      "import": "./dist/vue/forms/validation/index.js",
+      "default": "./dist/vue/forms/validation/index.js"
+    },
+    "./vue/requests": {
+      "types": "./dist/vue/requests/index.d.ts",
+      "import": "./dist/vue/requests/index.js",
+      "default": "./dist/vue/requests/index.js"
+    },
+    "./vue/router/routeResourceBinding": {
+      "types": "./dist/vue/router/routeResourceBinding/index.d.ts",
+      "import": "./dist/vue/router/routeResourceBinding/index.js",
+      "default": "./dist/vue/router/routeResourceBinding/index.js"
+    },
+    "./vue/state": {
+      "types": "./dist/vue/state/index.d.ts",
+      "import": "./dist/vue/state/index.js",
+      "default": "./dist/vue/state/index.js"
+    }
   },
   "scripts": {
     "dev": "vite",
-    "build": "run-p type-check \"build-only {@}\" --",
+    "build": "run-p type-check build:package \"build-only {@}\" --",
+    "build:package": "tsc -p tsconfig.build.json",
     "preview": "vite preview",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
@@ -34,15 +96,11 @@
     "format": "prettier --check src/",
     "format:fix": "prettier --write src/",
     "type-check": "tsc --noEmit",
+    "type-check:consumer-fixture": "npx --yes -p typescript@5.4.5 tsc -p ./tests/fixtures/consumer/tsconfig.json --pretty false",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
-  },
-  "optionalDependencies": {
-    "@rollup/rollup-linux-x64-gnu": "*",
-    "@rollup/rollup-linux-x64-musl": "*",
-    "@rollup/rollup-win32-x64-gnu": "*",
-    "@rollup/rollup-win32-x64-musl": "*"
+    "docs:preview": "vitepress preview docs",
+    "prepare": "npm run build:package"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.3.3",