@wirekyt/dom 0.0.1 → 0.0.2

package/dist/store-C5HvdLyc.js

@@ -0,0 +1,42 @@
+//#region src/common/utils/store.ts
+function createStore(initialState, compare = Object.is) {
+	let state = { ...initialState };
+	const listeners = /* @__PURE__ */ new Set();
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const publish = () => {
+		listeners.forEach((listener) => listener());
+	};
+	const get = (key) => {
+		return state[key];
+	};
+	const set = (key, value) => {
+		if (!compare(state[key], value)) {
+			state[key] = value;
+			publish();
+		}
+	};
+	const update = (updates) => {
+		let hasChanges = false;
+		for (const key in updates) {
+			const value = updates[key];
+			if (value !== void 0 && !compare(state[key], value)) {
+				state[key] = value;
+				hasChanges = true;
+			}
+		}
+		if (hasChanges) publish();
+	};
+	const snapshot = () => ({ ...state });
+	return {
+		subscribe,
+		get,
+		set,
+		update,
+		snapshot
+	};
+}
+//#endregion
+export { createStore as t };

package/dist/store-Wg8KVwNv.cjs

@@ -0,0 +1,298 @@
+let proxy_compare = require("proxy-compare");
+//#region src/common/store/global.ts
+function glob() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+}
+function globalRef(key, value) {
+	const g = glob();
+	if (!g) return value();
+	g[key] ||= value();
+	return g[key];
+}
+const refSet = globalRef("__wirekyt__refSet", () => /* @__PURE__ */ new WeakSet());
+//#endregion
+//#region src/common/store/utils.ts
+const isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x && "props" in x;
+const isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+const isDOMElement = (x) => typeof x === "object" && x !== null && "nodeType" in x && typeof x.nodeName === "string";
+const isElement = (x) => isReactElement(x) || isVueElement(x) || isDOMElement(x);
+const isObject = (x) => x !== null && typeof x === "object";
+const canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !isElement(x) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise) && !(x instanceof File) && !(x instanceof Blob) && !(x instanceof AbortController);
+const isDev = () => process.env.NODE_ENV !== "production";
+//#endregion
+//#region src/common/store/clone.ts
+function set(obj, key, val) {
+	if (typeof val.value === "object" && !canProxy(val.value)) val.value = clone(val.value);
+	if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") Object.defineProperty(obj, key, val);
+	else obj[key] = val.value;
+}
+function clone(x) {
+	if (typeof x !== "object") return x;
+	let i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
+	if (str === "[object Object]") tmp = Object.create(Object.getPrototypeOf(x) || null);
+	else if (str === "[object Array]") tmp = Array(x.length);
+	else if (str === "[object Set]") {
+		tmp = /* @__PURE__ */ new Set();
+		x.forEach(function(val) {
+			tmp.add(clone(val));
+		});
+	} else if (str === "[object Map]") {
+		tmp = /* @__PURE__ */ new Map();
+		x.forEach(function(val, key) {
+			tmp.set(clone(key), clone(val));
+		});
+	} else if (str === "[object Date]") tmp = /* @__PURE__ */ new Date(+x);
+	else if (str === "[object RegExp]") tmp = new RegExp(x.source, x.flags);
+	else if (str === "[object DataView]") tmp = new x.constructor(clone(x.buffer));
+	else if (str === "[object ArrayBuffer]") tmp = x.slice(0);
+	else if (str === "[object Blob]") tmp = x.slice();
+	else if (str.slice(-6) === "Array]") tmp = new x.constructor(x);
+	if (tmp) {
+		for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+		for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+			if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
+			set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+		}
+	}
+	return tmp || x;
+}
+//#endregion
+//#region src/common/store/proxy.ts
+const proxyStateMap = globalRef("__wirekyt__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version) => {
+	const cache = snapCache.get(target);
+	if (cache?.[0] === version) return cache[1];
+	const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+	(0, proxy_compare.markToTrack)(snap, true);
+	snapCache.set(target, [version, snap]);
+	Reflect.ownKeys(target).forEach((key) => {
+		const value = Reflect.get(target, key);
+		if (refSet.has(value)) {
+			(0, proxy_compare.markToTrack)(value, false);
+			snap[key] = value;
+		} else if (proxyStateMap.has(value)) snap[key] = snapshot(value);
+		else snap[key] = value;
+	});
+	return Object.freeze(snap);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction = (initialObject) => {
+	if (!isObject(initialObject)) throw new Error("object required");
+	const found = proxyCache.get(initialObject);
+	if (found) return found;
+	let version = versionHolder[0];
+	const listeners = /* @__PURE__ */ new Set();
+	const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+		if (version !== nextVersion) {
+			version = nextVersion;
+			listeners.forEach((listener) => listener(op, nextVersion));
+		}
+	};
+	let checkVersion = versionHolder[1];
+	const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
+		if (checkVersion !== nextCheckVersion && !listeners.size) {
+			checkVersion = nextCheckVersion;
+			propProxyStates.forEach(([propProxyState]) => {
+				const propVersion = propProxyState[1](nextCheckVersion);
+				if (propVersion > version) version = propVersion;
+			});
+		}
+		return version;
+	};
+	const createPropListener = (prop) => (op, nextVersion) => {
+		const newOp = [...op];
+		newOp[1] = [prop, ...newOp[1]];
+		notifyUpdate(newOp, nextVersion);
+	};
+	const propProxyStates = /* @__PURE__ */ new Map();
+	const addPropListener = (prop, propProxyState) => {
+		if (isDev() && propProxyStates.has(prop)) throw new Error("prop listener already exists");
+		if (listeners.size) {
+			const remove = propProxyState[3](createPropListener(prop));
+			propProxyStates.set(prop, [propProxyState, remove]);
+		} else propProxyStates.set(prop, [propProxyState]);
+	};
+	const removePropListener = (prop) => {
+		const entry = propProxyStates.get(prop);
+		if (entry) {
+			propProxyStates.delete(prop);
+			entry[1]?.();
+		}
+	};
+	const addListener = (listener) => {
+		listeners.add(listener);
+		if (listeners.size === 1) propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+			if (isDev() && prevRemove) throw new Error("remove already exists");
+			const remove = propProxyState[3](createPropListener(prop));
+			propProxyStates.set(prop, [propProxyState, remove]);
+		});
+		const removeListener = () => {
+			listeners.delete(listener);
+			if (listeners.size === 0) propProxyStates.forEach(([propProxyState, remove], prop) => {
+				if (remove) {
+					remove();
+					propProxyStates.set(prop, [propProxyState]);
+				}
+			});
+		};
+		return removeListener;
+	};
+	const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+	const proxyObject = newProxy(baseObject, {
+		deleteProperty(target, prop) {
+			const prevValue = Reflect.get(target, prop);
+			removePropListener(prop);
+			const deleted = Reflect.deleteProperty(target, prop);
+			if (deleted) notifyUpdate([
+				"delete",
+				[prop],
+				prevValue
+			]);
+			return deleted;
+		},
+		set(target, prop, value, receiver) {
+			const hasPrevValue = Reflect.has(target, prop);
+			const prevValue = Reflect.get(target, prop, receiver);
+			if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) return true;
+			removePropListener(prop);
+			if (isObject(value)) value = (0, proxy_compare.getUntracked)(value) || value;
+			let nextValue = value;
+			if (Object.getOwnPropertyDescriptor(target, prop)?.set) {} else {
+				if (!proxyStateMap.has(value) && canProxy(value)) nextValue = proxy(value);
+				const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
+				if (childProxyState) addPropListener(prop, childProxyState);
+			}
+			Reflect.set(target, prop, nextValue, receiver);
+			notifyUpdate([
+				"set",
+				[prop],
+				value,
+				prevValue
+			]);
+			return true;
+		}
+	});
+	proxyCache.set(initialObject, proxyObject);
+	const proxyState = [
+		baseObject,
+		ensureVersion,
+		createSnapshot,
+		addListener
+	];
+	proxyStateMap.set(proxyObject, proxyState);
+	Reflect.ownKeys(initialObject).forEach((key) => {
+		const desc = Object.getOwnPropertyDescriptor(initialObject, key);
+		if (desc.get || desc.set) Object.defineProperty(baseObject, key, desc);
+		else proxyObject[key] = initialObject[key];
+	});
+	return proxyObject;
+}) => [
+	proxyFunction,
+	proxyStateMap,
+	refSet,
+	objectIs,
+	newProxy,
+	canProxy,
+	snapCache,
+	createSnapshot,
+	proxyCache,
+	versionHolder
+];
+const [proxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+	return proxyFunction(initialObject);
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+	const proxyState = proxyStateMap.get(proxyObject);
+	if (isDev() && !proxyState) console.warn("Please use proxy object");
+	let promise;
+	const ops = [];
+	const addListener = proxyState[3];
+	let isListenerActive = false;
+	const listener = (op) => {
+		ops.push(op);
+		if (notifyInSync) {
+			callback(ops.splice(0));
+			return;
+		}
+		if (!promise) promise = Promise.resolve().then(() => {
+			promise = void 0;
+			if (isListenerActive) callback(ops.splice(0));
+		});
+	};
+	const removeListener = addListener(listener);
+	isListenerActive = true;
+	return () => {
+		isListenerActive = false;
+		removeListener();
+	};
+}
+function snapshot(proxyObject) {
+	const proxyState = proxyStateMap.get(proxyObject);
+	if (isDev() && !proxyState) console.warn("Please use proxy object");
+	const [target, ensureVersion, createSnapshot] = proxyState;
+	return createSnapshot(target, ensureVersion());
+}
+function ref(obj) {
+	refSet.add(obj);
+	return obj;
+}
+//#endregion
+//#region src/common/store/proxy-computed.ts
+function proxyWithComputed(initialObject, computedFns) {
+	Object.keys(computedFns).forEach((key) => {
+		if (Object.getOwnPropertyDescriptor(initialObject, key)) throw new Error("object property already defined");
+		const computedFn = computedFns[key];
+		const { get, set } = typeof computedFn === "function" ? { get: computedFn } : computedFn;
+		const desc = {};
+		desc.get = () => get(snapshot(proxyObject));
+		if (set) desc.set = (newValue) => set(proxyObject, newValue);
+		Object.defineProperty(initialObject, key, desc);
+	});
+	const proxyObject = proxy(initialObject);
+	return proxyObject;
+}
+//#endregion
+Object.defineProperty(exports, "clone", {
+	enumerable: true,
+	get: function() {
+		return clone;
+	}
+});
+Object.defineProperty(exports, "globalRef", {
+	enumerable: true,
+	get: function() {
+		return globalRef;
+	}
+});
+Object.defineProperty(exports, "proxy", {
+	enumerable: true,
+	get: function() {
+		return proxy;
+	}
+});
+Object.defineProperty(exports, "proxyWithComputed", {
+	enumerable: true,
+	get: function() {
+		return proxyWithComputed;
+	}
+});
+Object.defineProperty(exports, "ref", {
+	enumerable: true,
+	get: function() {
+		return ref;
+	}
+});
+Object.defineProperty(exports, "snapshot", {
+	enumerable: true,
+	get: function() {
+		return snapshot;
+	}
+});
+Object.defineProperty(exports, "subscribe", {
+	enumerable: true,
+	get: function() {
+		return subscribe;
+	}
+});

package/dist/store.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_store = require("./store-Wg8KVwNv.cjs");
+exports.clone = require_store.clone;
+exports.globalRef = require_store.globalRef;
+exports.proxy = require_store.proxy;
+exports.proxyWithComputed = require_store.proxyWithComputed;
+exports.ref = require_store.ref;
+exports.snapshot = require_store.snapshot;
+exports.subscribe = require_store.subscribe;

package/dist/store.d.cts

@@ -0,0 +1,26 @@
+//#region src/common/store/clone.d.ts
+declare function clone<T>(x: T): T;
+//#endregion
+//#region src/common/store/global.d.ts
+declare function globalRef<T>(key: string, value: () => T): T;
+//#endregion
+//#region src/common/store/proxy.d.ts
+type AsRef = {
+  $$valtioRef: true;
+};
+type Path = (string | symbol)[];
+type Op = [op: "set", path: Path, value: unknown, prevValue: unknown] | [op: "delete", path: Path, prevValue: unknown];
+type Snapshot<T> = T;
+declare function proxy<T extends object>(initialObject?: T): T;
+declare function subscribe<T extends object>(proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean): () => void;
+declare function snapshot<T extends object>(proxyObject: T): T;
+declare function ref<T extends object>(obj: T): Ref<T>;
+type Ref<T> = T & AsRef;
+//#endregion
+//#region src/common/store/proxy-computed.d.ts
+declare function proxyWithComputed<T extends object, U extends object>(initialObject: T, computedFns: { [K in keyof U]: ((snap: Snapshot<T>) => U[K]) | {
+  get: (snap: Snapshot<T>) => U[K];
+  set?: ((state: T, newValue: U[K]) => void) | undefined;
+}; }): T & U;
+//#endregion
+export { type Ref, type Snapshot, clone, globalRef, proxy, proxyWithComputed, ref, snapshot, subscribe };

package/dist/store.d.ts

@@ -0,0 +1,26 @@
+//#region src/common/store/clone.d.ts
+declare function clone<T>(x: T): T;
+//#endregion
+//#region src/common/store/global.d.ts
+declare function globalRef<T>(key: string, value: () => T): T;
+//#endregion
+//#region src/common/store/proxy.d.ts
+type AsRef = {
+  $$valtioRef: true;
+};
+type Path = (string | symbol)[];
+type Op = [op: "set", path: Path, value: unknown, prevValue: unknown] | [op: "delete", path: Path, prevValue: unknown];
+type Snapshot<T> = T;
+declare function proxy<T extends object>(initialObject?: T): T;
+declare function subscribe<T extends object>(proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean): () => void;
+declare function snapshot<T extends object>(proxyObject: T): T;
+declare function ref<T extends object>(obj: T): Ref<T>;
+type Ref<T> = T & AsRef;
+//#endregion
+//#region src/common/store/proxy-computed.d.ts
+declare function proxyWithComputed<T extends object, U extends object>(initialObject: T, computedFns: { [K in keyof U]: ((snap: Snapshot<T>) => U[K]) | {
+  get: (snap: Snapshot<T>) => U[K];
+  set?: ((state: T, newValue: U[K]) => void) | undefined;
+}; }): T & U;
+//#endregion
+export { type Ref, type Snapshot, clone, globalRef, proxy, proxyWithComputed, ref, snapshot, subscribe };

package/dist/store.js

@@ -0,0 +1,2 @@
+import { a as subscribe, i as snapshot, n as proxy, o as clone, r as ref, s as globalRef, t as proxyWithComputed } from "./store-BLpJlMxz.js";
+export { clone, globalRef, proxy, proxyWithComputed, ref, snapshot, subscribe };

package/dist/stringify-state.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+let json_format_highlight = require("json-format-highlight");
+json_format_highlight = require_rolldown_runtime.__toESM(json_format_highlight, 1);
+//#region src/common/stringify-state/index.ts
+const pick = (obj, keys) => Object.fromEntries(keys.filter((key) => key in obj).map((key) => [key, obj[key]]));
+const hasProp = (v, prop) => Object.prototype.hasOwnProperty.call(v, prop);
+const isTimeObject = (v) => hasProp(v, "hour") && hasProp(v, "minute") && hasProp(v, "second");
+const isMachine = (v) => [
+	"state",
+	"context",
+	"scope"
+].every((prop) => hasProp(v, prop));
+function stringifyState(state, omit) {
+	return JSON.stringify(state, (key, value) => {
+		try {
+			if (hasProp(value, "target") && hasProp(value, "timeStamp")) return pick(value, [
+				"type",
+				"target",
+				"currentTarget",
+				"relatedTarget"
+			]);
+			if (omit?.includes(key)) return;
+			if (hasProp(value, "calendar") || isTimeObject(value)) return value.toString();
+			if (typeof value?.json === "function") return value.json();
+			if (typeof value?.toJSON === "function") return value.toJSON();
+			if (Number.isNaN(value)) return "NaN";
+			if (value instanceof File) return value.name;
+			if (value instanceof Set) return Array.from(value);
+			if (isMachine(value)) return `Machine: ${value.scope.id}`;
+			switch (value?.toString()) {
+				case "[object ShadowRoot]": return "#shadow-root";
+				case "[object HTMLDocument]": return "#document";
+				case "[object Window]": return "#window";
+				case "[object AbortController]": return "#abort-controller";
+				default: return value !== null && typeof value === "object" && value.nodeType === 1 ? value.tagName : value;
+			}
+		} catch {
+			return value;
+		}
+	}, 4);
+}
+function highlightState(state, omit) {
+	return (0, json_format_highlight.default)(stringifyState(state, omit));
+}
+//#endregion
+exports.highlightState = highlightState;
+exports.stringifyState = stringifyState;

package/dist/stringify-state.d.cts

@@ -0,0 +1,8 @@
+//#region src/common/stringify-state/index.d.ts
+interface Dict {
+  [key: string]: any;
+}
+declare function stringifyState(state: Dict, omit?: string[]): string;
+declare function highlightState(state: Dict, omit?: string[]): any;
+//#endregion
+export { highlightState, stringifyState };

package/dist/stringify-state.d.ts

@@ -0,0 +1,8 @@
+//#region src/common/stringify-state/index.d.ts
+interface Dict {
+  [key: string]: any;
+}
+declare function stringifyState(state: Dict, omit?: string[]): string;
+declare function highlightState(state: Dict, omit?: string[]): any;
+//#endregion
+export { highlightState, stringifyState };

package/dist/stringify-state.js

@@ -0,0 +1,44 @@
+import formatHighlight from "json-format-highlight";
+//#region src/common/stringify-state/index.ts
+const pick = (obj, keys) => Object.fromEntries(keys.filter((key) => key in obj).map((key) => [key, obj[key]]));
+const hasProp = (v, prop) => Object.prototype.hasOwnProperty.call(v, prop);
+const isTimeObject = (v) => hasProp(v, "hour") && hasProp(v, "minute") && hasProp(v, "second");
+const isMachine = (v) => [
+	"state",
+	"context",
+	"scope"
+].every((prop) => hasProp(v, prop));
+function stringifyState(state, omit) {
+	return JSON.stringify(state, (key, value) => {
+		try {
+			if (hasProp(value, "target") && hasProp(value, "timeStamp")) return pick(value, [
+				"type",
+				"target",
+				"currentTarget",
+				"relatedTarget"
+			]);
+			if (omit?.includes(key)) return;
+			if (hasProp(value, "calendar") || isTimeObject(value)) return value.toString();
+			if (typeof value?.json === "function") return value.json();
+			if (typeof value?.toJSON === "function") return value.toJSON();
+			if (Number.isNaN(value)) return "NaN";
+			if (value instanceof File) return value.name;
+			if (value instanceof Set) return Array.from(value);
+			if (isMachine(value)) return `Machine: ${value.scope.id}`;
+			switch (value?.toString()) {
+				case "[object ShadowRoot]": return "#shadow-root";
+				case "[object HTMLDocument]": return "#document";
+				case "[object Window]": return "#window";
+				case "[object AbortController]": return "#abort-controller";
+				default: return value !== null && typeof value === "object" && value.nodeType === 1 ? value.tagName : value;
+			}
+		} catch {
+			return value;
+		}
+	}, 4);
+}
+function highlightState(state, omit) {
+	return formatHighlight(stringifyState(state, omit));
+}
+//#endregion
+export { highlightState, stringifyState };