@fumari/stf 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -75,6 +75,10 @@ interface DataEngineListener {
    * when `field` is specified, this is also fired when parent is deleted.
    */
   onDelete?: (key: FieldKey, ctx: OnDeleteContext) => void;
+  /**
+   * For listener attached to a namespace's engine, this is fired when the namespace is removed.
+   */
+  onUnmount?: () => void;
 }
 interface OnUpdateContext {
   /**
@@ -94,8 +98,7 @@ interface OnInitContext {
 }
 declare class DataEngine {
   private data;
-  /** namespace -> engine */
-  private namespaces;
+  private readonly namespaces;
   private readonly listeners;
   constructor(defaultValues?: DefaultValue<NonNullable<object>>);
   listen(listener: DataEngineListener): void;
@@ -119,7 +122,8 @@ declare class DataEngine {
    * create an isolated data engine
    */
   namespace(namespace: string, initialValue?: DefaultValue<NonNullable<object>>): DataEngine;
-  reset(data: Record<string, unknown>): void;
+  reset(data: NonNullable<object>): void;
+  clearNamespaces(): void;
 }
 declare function useFieldValue<V = unknown>(key: FieldKey, options?: {
   stf?: Stf | DataEngine;
@@ -135,5 +139,10 @@ declare function useFieldValue<V = unknown>(key: FieldKey, options?: {
 declare function useListener(listener: DataEngineListener & {
   stf?: Stf | DataEngine;
 }): void;
+declare function useNamespace(options: {
+  namespace: string;
+  initial?: DefaultValue<NonNullable<object>>;
+  stf?: Stf | DataEngine;
+}): DataEngine;
 //#endregion
-export { ArrayItemInfo, DataEngine, DataEngineListener, DefaultValue, FieldKey, OnDeleteContext, OnInitContext, OnUpdateContext, PropertyItemInfo, Stf, StfProvider, useArray, useDataEngine, useFieldValue, useListener, useObject, useStf };
+export { ArrayItemInfo, DataEngine, DataEngineListener, DefaultValue, FieldKey, OnDeleteContext, OnInitContext, OnUpdateContext, PropertyItemInfo, Stf, StfProvider, useArray, useDataEngine, useFieldValue, useListener, useNamespace, useObject, useStf };

package/dist/index.js

@@ -1,6 +1,6 @@
 'use client';
 
-import { deepEqual, fieldKeyStartsWith, objectGet, objectSet, stringifyFieldKey } from "./lib/utils.js";
+import { deepEqual, fieldKeyStartsWith, isPlainObject, objectGet, objectSet, stringifyFieldKey } from "./lib/utils.js";
 import { createContext, use, useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 
@@ -160,6 +160,10 @@ var ListenerManager = class {
 			for (const v of listeners) v.onDelete?.(field, ctx);
 		}
 	}
+	onUnmount() {
+		for (const v of this.unindexed) v.onUnmount?.();
+		for (const listeners of this.indexed.values()) for (const v of listeners) v.onUnmount?.();
+	}
 };
 var DataEngine = class DataEngine {
 	constructor(defaultValues = {}) {
@@ -184,28 +188,33 @@ var DataEngine = class DataEngine {
 	*/
 	init(key, defaultValue, ctx = {}) {
 		if (key.length === 0) return this.data;
-		let cur = this.data;
-		const currentKey = [];
+		const parentKey = [];
 		const parentUpdateCtx = {
 			swallow: true,
 			...ctx
 		};
+		let cur = this.data;
 		for (let i = 0; i < key.length; i++) {
 			const propKey = key[i];
 			const propValue = cur[propKey];
 			if (i === key.length - 1) {
 				if (propValue !== void 0) return propValue;
 				cur[propKey] = getDefaultValue(defaultValue);
-				this.listeners.onUpdate(currentKey, parentUpdateCtx);
+				this.listeners.onUpdate(parentKey, parentUpdateCtx);
 				this.listeners.onInit(key, ctx);
 				return cur[propKey];
-			} else if (typeof propValue === "object" && propValue !== null) cur = propValue;
-			else {
-				if (propValue !== void 0) console.warn(`the original value of field ${currentKey.join(".")} is overidden, this might be unexpected.`);
+			} else if (isPlainObject(propValue)) {
+				cur = propValue;
+				parentKey.push(propKey);
+			} else {
 				cur = cur[propKey] = {};
-				this.listeners.onUpdate(currentKey, parentUpdateCtx);
+				this.listeners.onUpdate(parentKey, parentUpdateCtx);
+				parentKey.push(propKey);
+				if (propValue !== void 0) {
+					console.warn(`the original value of field ${parentKey.join(".")} is overidden, this might be unexpected.`);
+					this.listeners.onUpdate(parentKey, parentUpdateCtx);
+				}
 			}
-			currentKey.push(propKey);
 		}
 	}
 	delete(key, ctx = {}) {
@@ -222,7 +231,7 @@ var DataEngine = class DataEngine {
 				...ctx
 			});
 			return deleted[0];
-		} else if (typeof parent === "object" && parent !== null) {
+		} else if (isPlainObject(parent)) {
 			const temp = parent[prop];
 			delete parent[prop];
 			this.listeners.onDelete(key, ctx);
@@ -264,17 +273,27 @@ var DataEngine = class DataEngine {
 		return child;
 	}
 	reset(data) {
-		this.namespaces.clear();
 		this.update([], data);
 	}
+	clearNamespaces() {
+		for (const [name, engine] of this.namespaces) {
+			this.namespaces.delete(name);
+			engine.listeners.onUnmount();
+		}
+	}
 };
 function useFieldValue(key, options = {}) {
-	const engine = useDataEngine(options.stf);
-	const { compute = (v) => v, defaultValue, isChanged = (a, b) => a !== b } = options;
+	const { stf, compute = (v) => v, defaultValue, isChanged = (a, b) => a !== b } = options;
+	const engine = useDataEngine(stf);
 	const [value, setValue] = useState(() => compute(engine.init(key, defaultValue)));
+	const prevEngineRef = useRef(engine);
+	if (prevEngineRef.current !== engine) {
+		setValue(compute(engine.init(key, defaultValue)));
+		prevEngineRef.current = engine;
+	}
 	useListener({
 		field: key,
-		stf: options.stf,
+		stf,
 		onInit() {
 			const computed = compute(engine.get(key));
 			setValue((prev) => isChanged(prev, computed) ? computed : prev);
@@ -297,6 +316,9 @@ function useListener(listener) {
 	useEffect(() => {
 		const internal = {
 			field: listener.field,
+			onUnmount(...args) {
+				return listenerRef.current.onUnmount?.(...args);
+			},
 			onDelete(...args) {
 				return listenerRef.current.onDelete?.(...args);
 			},
@@ -313,6 +335,18 @@ function useListener(listener) {
 		};
 	}, [engine, listener.field]);
 }
+function useNamespace(options) {
+	const { namespace, stf, initial } = options;
+	const engine = useDataEngine(stf);
+	const [value, setValue] = useState(() => engine.namespace(namespace, initial));
+	useListener({
+		stf: value,
+		onUnmount() {
+			setValue(engine.namespace(namespace, initial));
+		}
+	});
+	return value;
+}
 
 //#endregion
-export { DataEngine, StfProvider, useArray, useDataEngine, useFieldValue, useListener, useObject, useStf };
+export { DataEngine, StfProvider, useArray, useDataEngine, useFieldValue, useListener, useNamespace, useObject, useStf };

package/dist/lib/utils.d.ts

@@ -17,5 +17,6 @@ declare function stringifyFieldKey(fieldKey: FieldKey): string;
  * @returns if `a` starts with `b`.
  */
 declare function fieldKeyStartsWith(a: string, b: string): boolean;
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 //#endregion
-export { deepEqual, fieldKeyStartsWith, objectGet, objectSet, stringifyFieldKey };
+export { deepEqual, fieldKeyStartsWith, isPlainObject, objectGet, objectSet, stringifyFieldKey };

package/dist/lib/utils.js

@@ -2,7 +2,7 @@
 function objectGet(obj, key) {
 	let cur = obj;
 	for (const prop of key) {
-		if (typeof cur !== "object" || cur === null || !(prop in cur)) return;
+		if (!isPlainObject(cur) || !(prop in cur)) return;
 		cur = cur[prop];
 	}
 	return cur;
@@ -15,7 +15,7 @@ function objectGet(obj, key) {
 function objectSet(obj, key, value) {
 	if (key.length === 0) return value;
 	const parent = objectGet(obj, key.slice(0, -1));
-	if (typeof parent !== "object" || parent === null) throw new Error("missing parent object");
+	if (!isPlainObject(parent)) throw new Error("missing parent object");
 	parent[key[key.length - 1]] = value;
 	return obj;
 }
@@ -31,13 +31,14 @@ function deepEqual(a, b) {
 		return a.every((item, index) => deepEqual(item, b[index]));
 	}
 	if (Array.isArray(a) || Array.isArray(b)) return false;
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
 	const keysA = Object.keys(a);
 	const keysB = Object.keys(b);
 	if (keysA.length !== keysB.length) return false;
-	return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key]));
+	return keysA.every((key) => key in b && deepEqual(a[key], b[key]));
 }
 function stringifyFieldKey(fieldKey) {
-	return fieldKey.map((v) => `${typeof v}:${v}`).join(".");
+	return fieldKey.map((v) => typeof v === "string" ? `_${v}` : `n${v}`).join(".");
 }
 /**
 * @returns if `a` starts with `b`.
@@ -45,6 +46,11 @@ function stringifyFieldKey(fieldKey) {
 function fieldKeyStartsWith(a, b) {
 	return b.length === 0 || a === b || a.startsWith(b + ".");
 }
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
 
 //#endregion
-export { deepEqual, fieldKeyStartsWith, objectGet, objectSet, stringifyFieldKey };
+export { deepEqual, fieldKeyStartsWith, isPlainObject, objectGet, objectSet, stringifyFieldKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fumari/stf",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Schema to Form.",
   "keywords": [],
   "license": "MIT",