@wirekyt/dom 0.0.1 → 0.0.2

package/dist/scroll-snap.d.cts

@@ -0,0 +1,14 @@
+//#region src/common/scroll-snap/index.d.ts
+type ScrollAxis = "x" | "y";
+type ScrollDirection = "left" | "right" | "up" | "down";
+type ScrollSnapAlignment = "start" | "end" | "center" | "none";
+type SnapPositionList = Record<Exclude<ScrollSnapAlignment, "none">, Array<{
+  node: Element;
+  position: number;
+}>>;
+declare function getSnapPositions(parent: HTMLElement, subtree?: boolean): Record<ScrollAxis, SnapPositionList>;
+declare function getScrollSnapPositions(element: HTMLElement): Record<ScrollAxis, number[]>;
+declare function findSnapPoint(parent: HTMLElement, axis: ScrollAxis, predicate: (node: HTMLElement) => boolean): number | undefined;
+declare function getSnapPointTarget(parent: HTMLElement, snapPoint: number): HTMLElement;
+//#endregion
+export { ScrollAxis, ScrollDirection, ScrollSnapAlignment, SnapPositionList, findSnapPoint, getScrollSnapPositions, getSnapPointTarget, getSnapPositions };

package/dist/scroll-snap.d.ts

@@ -0,0 +1,14 @@
+//#region src/common/scroll-snap/index.d.ts
+type ScrollAxis = "x" | "y";
+type ScrollDirection = "left" | "right" | "up" | "down";
+type ScrollSnapAlignment = "start" | "end" | "center" | "none";
+type SnapPositionList = Record<Exclude<ScrollSnapAlignment, "none">, Array<{
+  node: Element;
+  position: number;
+}>>;
+declare function getSnapPositions(parent: HTMLElement, subtree?: boolean): Record<ScrollAxis, SnapPositionList>;
+declare function getScrollSnapPositions(element: HTMLElement): Record<ScrollAxis, number[]>;
+declare function findSnapPoint(parent: HTMLElement, axis: ScrollAxis, predicate: (node: HTMLElement) => boolean): number | undefined;
+declare function getSnapPointTarget(parent: HTMLElement, snapPoint: number): HTMLElement;
+//#endregion
+export { ScrollAxis, ScrollDirection, ScrollSnapAlignment, SnapPositionList, findSnapPoint, getScrollSnapPositions, getSnapPointTarget, getSnapPositions };

package/dist/scroll-snap.js

@@ -0,0 +1,2 @@
+import { i as getSnapPositions, n as getScrollSnapPositions, r as getSnapPointTarget, t as findSnapPoint } from "./scroll-snap-DqMiFASa.js";
+export { findSnapPoint, getScrollSnapPositions, getSnapPointTarget, getSnapPositions };

package/dist/selection-ClKhnWit.d.cts

@@ -0,0 +1,49 @@
+import { r as CollectionOptions, t as CollectionItem } from "./types-CczqoQLL.cjs";
+import { t as ListCollection } from "./list-collection-D_eNKrot.cjs";
+//#region src/common/collection/grid-collection.d.ts
+interface GridCollectionOptions<T> extends CollectionOptions<T> {
+  columnCount: number;
+}
+declare class GridCollection<T extends CollectionItem = CollectionItem> extends ListCollection<T> {
+  columnCount: number;
+  private rows;
+  constructor(options: GridCollectionOptions<T>);
+  getRows: () => T[][];
+  getRowCount: () => number;
+  getCellIndex: (row: number, column: number) => number;
+  getCell: (row: number, column: number) => T | null;
+  getValueCell: (value: string) => {
+    row: number;
+    column: number;
+  } | null;
+  getLastEnabledColumnIndex: (row: number) => number | null;
+  getFirstEnabledColumnIndex: (row: number) => number | null;
+  getPreviousRowValue: (value: string, loop?: boolean) => string | null;
+  getNextRowValue: (value: string, loop?: boolean) => string | null;
+}
+declare function isGridCollection(v: any): v is GridCollection<any>;
+//#endregion
+//#region src/common/collection/selection.d.ts
+type SelectionMode = "single" | "multiple" | "none" | "extended";
+declare class Selection extends Set<string> {
+  selectionMode: SelectionMode;
+  deselectable: boolean;
+  constructor(values?: Iterable<string>);
+  copy: () => Selection;
+  private sync;
+  isEmpty: () => boolean;
+  isSelected: (value: string | null) => boolean;
+  canSelect: (collection: ListCollection, value: string) => boolean;
+  firstSelectedValue: (collection: ListCollection) => string | null;
+  lastSelectedValue: (collection: ListCollection) => string | null;
+  extendSelection: (collection: ListCollection, anchorValue: string, targetValue: string) => Selection;
+  toggleSelection: (collection: ListCollection, value: string) => Selection;
+  replaceSelection: (collection: ListCollection, value: string | null) => Selection;
+  setSelection: (values: Iterable<string>) => Selection;
+  clearSelection: () => Selection;
+  select: (collection: ListCollection, value: string, forceToggle?: boolean) => Selection;
+  deselect: (value: string) => Selection;
+  isEqual: (other: Selection) => boolean;
+}
+//#endregion
+export { isGridCollection as a, GridCollectionOptions as i, SelectionMode as n, GridCollection as r, Selection as t };

package/dist/selection-DzLiSVkg.d.ts

@@ -0,0 +1,49 @@
+import { r as CollectionOptions, t as CollectionItem } from "./types-CczqoQLL.js";
+import { t as ListCollection } from "./list-collection-RqYEWHb4.js";
+//#region src/common/collection/grid-collection.d.ts
+interface GridCollectionOptions<T> extends CollectionOptions<T> {
+  columnCount: number;
+}
+declare class GridCollection<T extends CollectionItem = CollectionItem> extends ListCollection<T> {
+  columnCount: number;
+  private rows;
+  constructor(options: GridCollectionOptions<T>);
+  getRows: () => T[][];
+  getRowCount: () => number;
+  getCellIndex: (row: number, column: number) => number;
+  getCell: (row: number, column: number) => T | null;
+  getValueCell: (value: string) => {
+    row: number;
+    column: number;
+  } | null;
+  getLastEnabledColumnIndex: (row: number) => number | null;
+  getFirstEnabledColumnIndex: (row: number) => number | null;
+  getPreviousRowValue: (value: string, loop?: boolean) => string | null;
+  getNextRowValue: (value: string, loop?: boolean) => string | null;
+}
+declare function isGridCollection(v: any): v is GridCollection<any>;
+//#endregion
+//#region src/common/collection/selection.d.ts
+type SelectionMode = "single" | "multiple" | "none" | "extended";
+declare class Selection extends Set<string> {
+  selectionMode: SelectionMode;
+  deselectable: boolean;
+  constructor(values?: Iterable<string>);
+  copy: () => Selection;
+  private sync;
+  isEmpty: () => boolean;
+  isSelected: (value: string | null) => boolean;
+  canSelect: (collection: ListCollection, value: string) => boolean;
+  firstSelectedValue: (collection: ListCollection) => string | null;
+  lastSelectedValue: (collection: ListCollection) => string | null;
+  extendSelection: (collection: ListCollection, anchorValue: string, targetValue: string) => Selection;
+  toggleSelection: (collection: ListCollection, value: string) => Selection;
+  replaceSelection: (collection: ListCollection, value: string | null) => Selection;
+  setSelection: (values: Iterable<string>) => Selection;
+  clearSelection: () => Selection;
+  select: (collection: ListCollection, value: string, forceToggle?: boolean) => Selection;
+  deselect: (value: string) => Selection;
+  isEqual: (other: Selection) => boolean;
+}
+//#endregion
+export { isGridCollection as a, GridCollectionOptions as i, SelectionMode as n, GridCollection as r, Selection as t };

package/dist/selection-map-962WvX2k.js

@@ -0,0 +1,45 @@
+//#region src/common/collection/selection-map.ts
+function resolveSelectedItems({ values, collection, selectedItemMap }) {
+	const result = [];
+	for (const value of values) {
+		const item = collection.find(value) ?? selectedItemMap.get(value);
+		if (item != null) result.push(item);
+	}
+	return result;
+}
+function updateSelectedItemMap({ selectedItemMap, values, selectedItems, collection }) {
+	const nextMap = new Map(selectedItemMap);
+	for (const item of selectedItems) {
+		const value = collection.getItemValue(item);
+		if (value != null) nextMap.set(value, item);
+	}
+	const allowedValues = new Set(values);
+	for (const value of nextMap.keys()) if (!allowedValues.has(value)) nextMap.delete(value);
+	return nextMap;
+}
+function deriveSelectionState({ values, collection, selectedItemMap }) {
+	const selectedItems = resolveSelectedItems({
+		values,
+		collection,
+		selectedItemMap
+	});
+	return {
+		selectedItems,
+		nextSelectedItemMap: updateSelectedItemMap({
+			selectedItemMap,
+			values,
+			selectedItems,
+			collection
+		})
+	};
+}
+function createSelectedItemMap({ selectedItems, collection }) {
+	return updateSelectedItemMap({
+		selectedItemMap: /* @__PURE__ */ new Map(),
+		values: selectedItems.map((item) => collection.getItemValue(item)).filter(Boolean),
+		selectedItems,
+		collection
+	});
+}
+//#endregion
+export { updateSelectedItemMap as i, deriveSelectionState as n, resolveSelectedItems as r, createSelectedItemMap as t };

package/dist/selection-map-BwlZr1LH.cjs

@@ -0,0 +1,68 @@
+//#region src/common/collection/selection-map.ts
+function resolveSelectedItems({ values, collection, selectedItemMap }) {
+	const result = [];
+	for (const value of values) {
+		const item = collection.find(value) ?? selectedItemMap.get(value);
+		if (item != null) result.push(item);
+	}
+	return result;
+}
+function updateSelectedItemMap({ selectedItemMap, values, selectedItems, collection }) {
+	const nextMap = new Map(selectedItemMap);
+	for (const item of selectedItems) {
+		const value = collection.getItemValue(item);
+		if (value != null) nextMap.set(value, item);
+	}
+	const allowedValues = new Set(values);
+	for (const value of nextMap.keys()) if (!allowedValues.has(value)) nextMap.delete(value);
+	return nextMap;
+}
+function deriveSelectionState({ values, collection, selectedItemMap }) {
+	const selectedItems = resolveSelectedItems({
+		values,
+		collection,
+		selectedItemMap
+	});
+	return {
+		selectedItems,
+		nextSelectedItemMap: updateSelectedItemMap({
+			selectedItemMap,
+			values,
+			selectedItems,
+			collection
+		})
+	};
+}
+function createSelectedItemMap({ selectedItems, collection }) {
+	return updateSelectedItemMap({
+		selectedItemMap: /* @__PURE__ */ new Map(),
+		values: selectedItems.map((item) => collection.getItemValue(item)).filter(Boolean),
+		selectedItems,
+		collection
+	});
+}
+//#endregion
+Object.defineProperty(exports, "createSelectedItemMap", {
+	enumerable: true,
+	get: function() {
+		return createSelectedItemMap;
+	}
+});
+Object.defineProperty(exports, "deriveSelectionState", {
+	enumerable: true,
+	get: function() {
+		return deriveSelectionState;
+	}
+});
+Object.defineProperty(exports, "resolveSelectedItems", {
+	enumerable: true,
+	get: function() {
+		return resolveSelectedItems;
+	}
+});
+Object.defineProperty(exports, "updateSelectedItemMap", {
+	enumerable: true,
+	get: function() {
+		return updateSelectedItemMap;
+	}
+});

package/dist/set-CFNGOW5W.js

@@ -0,0 +1,50 @@
+import { B as noop } from "./dom-query-e7fh0TEH.js";
+//#region src/common/dom-query/set.ts
+function setAttribute(el, attr, v) {
+	const prev = el.getAttribute(attr);
+	const exists = prev != null;
+	if (prev === v) return noop;
+	el.setAttribute(attr, v);
+	return () => {
+		if (!exists) el.removeAttribute(attr);
+		else el.setAttribute(attr, prev);
+	};
+}
+function setProperty(el, prop, v) {
+	const exists = prop in el;
+	const prev = el[prop];
+	if (prev === v) return noop;
+	el[prop] = v;
+	return () => {
+		if (!exists) delete el[prop];
+		else el[prop] = prev;
+	};
+}
+function setStyle(el, style) {
+	if (!el) return noop;
+	const prev = Object.keys(style).reduce((acc, key) => {
+		acc[key] = el.style.getPropertyValue(key);
+		return acc;
+	}, {});
+	if (isEqual(prev, style)) return noop;
+	Object.assign(el.style, style);
+	return () => {
+		Object.assign(el.style, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function setStyleProperty(el, prop, value) {
+	if (!el) return noop;
+	const prev = el.style.getPropertyValue(prop);
+	if (prev === value) return noop;
+	el.style.setProperty(prop, value);
+	return () => {
+		el.style.setProperty(prop, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function isEqual(a, b) {
+	return Object.keys(a).every((key) => a[key] === b[key]);
+}
+//#endregion
+export { setStyleProperty as i, setProperty as n, setStyle as r, setAttribute as t };

package/dist/set-DrtWCLFb.cjs

@@ -0,0 +1,73 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+//#region src/common/dom-query/set.ts
+function setAttribute(el, attr, v) {
+	const prev = el.getAttribute(attr);
+	const exists = prev != null;
+	if (prev === v) return require_dom_query.noop;
+	el.setAttribute(attr, v);
+	return () => {
+		if (!exists) el.removeAttribute(attr);
+		else el.setAttribute(attr, prev);
+	};
+}
+function setProperty(el, prop, v) {
+	const exists = prop in el;
+	const prev = el[prop];
+	if (prev === v) return require_dom_query.noop;
+	el[prop] = v;
+	return () => {
+		if (!exists) delete el[prop];
+		else el[prop] = prev;
+	};
+}
+function setStyle(el, style) {
+	if (!el) return require_dom_query.noop;
+	const prev = Object.keys(style).reduce((acc, key) => {
+		acc[key] = el.style.getPropertyValue(key);
+		return acc;
+	}, {});
+	if (isEqual(prev, style)) return require_dom_query.noop;
+	Object.assign(el.style, style);
+	return () => {
+		Object.assign(el.style, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function setStyleProperty(el, prop, value) {
+	if (!el) return require_dom_query.noop;
+	const prev = el.style.getPropertyValue(prop);
+	if (prev === value) return require_dom_query.noop;
+	el.style.setProperty(prop, value);
+	return () => {
+		el.style.setProperty(prop, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function isEqual(a, b) {
+	return Object.keys(a).every((key) => a[key] === b[key]);
+}
+//#endregion
+Object.defineProperty(exports, "setAttribute", {
+	enumerable: true,
+	get: function() {
+		return setAttribute;
+	}
+});
+Object.defineProperty(exports, "setProperty", {
+	enumerable: true,
+	get: function() {
+		return setProperty;
+	}
+});
+Object.defineProperty(exports, "setStyle", {
+	enumerable: true,
+	get: function() {
+		return setStyle;
+	}
+});
+Object.defineProperty(exports, "setStyleProperty", {
+	enumerable: true,
+	get: function() {
+		return setStyleProperty;
+	}
+});

package/dist/store-BLpJlMxz.js

@@ -0,0 +1,257 @@
+import { getUntracked, markToTrack } from "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));
+	markToTrack(snap, true);
+	snapCache.set(target, [version, snap]);
+	Reflect.ownKeys(target).forEach((key) => {
+		const value = Reflect.get(target, key);
+		if (refSet.has(value)) {
+			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 = 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
+export { subscribe as a, snapshot as i, proxy as n, clone as o, ref as r, globalRef as s, proxyWithComputed as t };

package/dist/store-Btfrm2bs.cjs

@@ -0,0 +1,47 @@
+//#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
+Object.defineProperty(exports, "createStore", {
+	enumerable: true,
+	get: function() {
+		return createStore;
+	}
+});