New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
@zag-js/store
Advanced tools
@zag-js/store - npm Package Compare versions
Comparing version 0.0.0-dev-20230601120732 to 0.0.0-dev-20230605130234
@@ -1,3 +0,3 @@ | ||
| export { Snapshot, proxy, ref, snapshot, subscribe } from './proxy.js'; | ||
| export { proxyWithComputed } from './proxy-computed.js'; | ||
| export { subscribeKey } from './subscribe-key.js'; | ||
| export { proxy, ref, snapshot, subscribe, type Snapshot } from "./proxy"; | ||
| export { proxyWithComputed } from "./proxy-computed"; | ||
| export { subscribeKey } from "./subscribe-key"; |
@@ -1,316 +0,16 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| // src/index.ts | ||
| var src_exports = {}; | ||
| __export(src_exports, { | ||
| proxy: () => proxy, | ||
| proxyWithComputed: () => proxyWithComputed, | ||
| ref: () => ref, | ||
| snapshot: () => snapshot, | ||
| subscribe: () => subscribe, | ||
| subscribeKey: () => subscribeKey | ||
| }); | ||
| module.exports = __toCommonJS(src_exports); | ||
| Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); | ||
| // src/proxy.ts | ||
| var import_proxy_compare = require("proxy-compare"); | ||
| var isDev = process.env.NODE_ENV !== "production"; | ||
| var isObject = (x) => typeof x === "object" && x !== null; | ||
| var proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
| var refSet = /* @__PURE__ */ new WeakSet(); | ||
| var buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in 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), defaultHandlePromise = (promise) => { | ||
| switch (promise.status) { | ||
| case "fulfilled": | ||
| return promise.value; | ||
| case "rejected": | ||
| throw promise.reason; | ||
| default: | ||
| throw promise; | ||
| } | ||
| }, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => { | ||
| const cache = snapCache.get(target); | ||
| if (cache?.[0] === version) { | ||
| return cache[1]; | ||
| } | ||
| const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
| (0, import_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, import_proxy_compare.markToTrack)(value, false); | ||
| snap[key] = value; | ||
| } else if (value instanceof Promise) { | ||
| Object.defineProperty(snap, key, { | ||
| get() { | ||
| return handlePromise(value); | ||
| } | ||
| }); | ||
| } else if (proxyStateMap.has(value)) { | ||
| snap[key] = snapshot(value, handlePromise); | ||
| } else { | ||
| snap[key] = value; | ||
| } | ||
| }); | ||
| return Object.freeze(snap); | ||
| }, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction2 = (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 handler = { | ||
| 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, import_proxy_compare.getUntracked)(value) || value; | ||
| } | ||
| let nextValue = value; | ||
| if (Object.getOwnPropertyDescriptor(target, prop)?.set) { | ||
| } else if (value instanceof Promise) { | ||
| value.then((v) => { | ||
| value.status = "fulfilled"; | ||
| value.value = v; | ||
| notifyUpdate(["resolve", [prop], v]); | ||
| }).catch((e) => { | ||
| value.status = "rejected"; | ||
| value.reason = e; | ||
| notifyUpdate(["reject", [prop], e]); | ||
| }); | ||
| } 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; | ||
| } | ||
| }; | ||
| const proxyObject = newProxy(baseObject, handler); | ||
| 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; | ||
| }) => [ | ||
| // public functions | ||
| proxyFunction2, | ||
| // shared state | ||
| proxyStateMap, | ||
| refSet, | ||
| // internal things | ||
| objectIs, | ||
| newProxy, | ||
| canProxy, | ||
| defaultHandlePromise, | ||
| snapCache, | ||
| createSnapshot, | ||
| proxyCache, | ||
| versionHolder | ||
| ]; | ||
| var [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, handlePromise) { | ||
| const proxyState = proxyStateMap.get(proxyObject); | ||
| if (isDev && !proxyState) { | ||
| console.warn("Please use proxy object"); | ||
| } | ||
| const [target, ensureVersion, createSnapshot] = proxyState; | ||
| return createSnapshot(target, ensureVersion(), handlePromise); | ||
| } | ||
| function ref(obj) { | ||
| refSet.add(obj); | ||
| return obj; | ||
| } | ||
| const proxy = require('./proxy.js'); | ||
| const proxyComputed = require('./proxy-computed.js'); | ||
| const subscribeKey = require('./subscribe-key.js'); | ||
| // src/proxy-computed.ts | ||
| function proxyWithComputed(initialObject, computedFns) { | ||
| const keys = Object.keys(computedFns); | ||
| keys.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; | ||
| } | ||
| // src/subscribe-key.ts | ||
| var defaultCompareFn = (prev, next) => Object.is(prev, next); | ||
| function subscribeKey(obj, key, fn, sync, compareFn) { | ||
| let prev = Reflect.get(snapshot(obj), key); | ||
| const isEqual = compareFn || defaultCompareFn; | ||
| function onSnapshotChange() { | ||
| const snap = snapshot(obj); | ||
| if (isEqual(prev, snap[key])) | ||
| return; | ||
| fn(snap[key]); | ||
| prev = Reflect.get(snap, key); | ||
| } | ||
| return subscribe(obj, onSnapshotChange, sync); | ||
| } | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| proxy, | ||
| proxyWithComputed, | ||
| ref, | ||
| snapshot, | ||
| subscribe, | ||
| subscribeKey | ||
| }); | ||
| exports.proxy = proxy.proxy; | ||
| exports.ref = proxy.ref; | ||
| exports.snapshot = proxy.snapshot; | ||
| exports.subscribe = proxy.subscribe; | ||
| exports.proxyWithComputed = proxyComputed.proxyWithComputed; | ||
| exports.subscribeKey = subscribeKey.subscribeKey; |
@@ -1,4 +0,3 @@ | ||
| import { Snapshot } from './proxy.js'; | ||
| declare function proxyWithComputed<T extends object, U extends object>(initialObject: T, computedFns: { | ||
| import { Snapshot } from "./proxy"; | ||
| export declare function proxyWithComputed<T extends object, U extends object>(initialObject: T, computedFns: { | ||
| [K in keyof U]: ((snap: Snapshot<T>) => U[K]) | { | ||
@@ -9,3 +8,1 @@ get: (snap: Snapshot<T>) => U[K]; | ||
| }): T & U; | ||
| export { proxyWithComputed }; |
@@ -1,235 +0,7 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| // src/proxy-computed.ts | ||
| var proxy_computed_exports = {}; | ||
| __export(proxy_computed_exports, { | ||
| proxyWithComputed: () => proxyWithComputed | ||
| }); | ||
| module.exports = __toCommonJS(proxy_computed_exports); | ||
| Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); | ||
| // src/proxy.ts | ||
| var import_proxy_compare = require("proxy-compare"); | ||
| var isDev = process.env.NODE_ENV !== "production"; | ||
| var isObject = (x) => typeof x === "object" && x !== null; | ||
| var proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
| var refSet = /* @__PURE__ */ new WeakSet(); | ||
| var buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in 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), defaultHandlePromise = (promise) => { | ||
| switch (promise.status) { | ||
| case "fulfilled": | ||
| return promise.value; | ||
| case "rejected": | ||
| throw promise.reason; | ||
| default: | ||
| throw promise; | ||
| } | ||
| }, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => { | ||
| const cache = snapCache.get(target); | ||
| if (cache?.[0] === version) { | ||
| return cache[1]; | ||
| } | ||
| const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
| (0, import_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, import_proxy_compare.markToTrack)(value, false); | ||
| snap[key] = value; | ||
| } else if (value instanceof Promise) { | ||
| Object.defineProperty(snap, key, { | ||
| get() { | ||
| return handlePromise(value); | ||
| } | ||
| }); | ||
| } else if (proxyStateMap.has(value)) { | ||
| snap[key] = snapshot(value, handlePromise); | ||
| } else { | ||
| snap[key] = value; | ||
| } | ||
| }); | ||
| return Object.freeze(snap); | ||
| }, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction2 = (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 handler = { | ||
| 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, import_proxy_compare.getUntracked)(value) || value; | ||
| } | ||
| let nextValue = value; | ||
| if (Object.getOwnPropertyDescriptor(target, prop)?.set) { | ||
| } else if (value instanceof Promise) { | ||
| value.then((v) => { | ||
| value.status = "fulfilled"; | ||
| value.value = v; | ||
| notifyUpdate(["resolve", [prop], v]); | ||
| }).catch((e) => { | ||
| value.status = "rejected"; | ||
| value.reason = e; | ||
| notifyUpdate(["reject", [prop], e]); | ||
| }); | ||
| } 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; | ||
| } | ||
| }; | ||
| const proxyObject = newProxy(baseObject, handler); | ||
| 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; | ||
| }) => [ | ||
| // public functions | ||
| proxyFunction2, | ||
| // shared state | ||
| proxyStateMap, | ||
| refSet, | ||
| // internal things | ||
| objectIs, | ||
| newProxy, | ||
| canProxy, | ||
| defaultHandlePromise, | ||
| snapCache, | ||
| createSnapshot, | ||
| proxyCache, | ||
| versionHolder | ||
| ]; | ||
| var [proxyFunction] = buildProxyFunction(); | ||
| function proxy(initialObject = {}) { | ||
| return proxyFunction(initialObject); | ||
| } | ||
| function snapshot(proxyObject, handlePromise) { | ||
| const proxyState = proxyStateMap.get(proxyObject); | ||
| if (isDev && !proxyState) { | ||
| console.warn("Please use proxy object"); | ||
| } | ||
| const [target, ensureVersion, createSnapshot] = proxyState; | ||
| return createSnapshot(target, ensureVersion(), handlePromise); | ||
| } | ||
| const proxy = require('./proxy.js'); | ||
| // src/proxy-computed.ts | ||
| function proxyWithComputed(initialObject, computedFns) { | ||
@@ -244,3 +16,3 @@ const keys = Object.keys(computedFns); | ||
| const desc = {}; | ||
| desc.get = () => get(snapshot(proxyObject)); | ||
| desc.get = () => get(proxy.snapshot(proxyObject)); | ||
| if (set) { | ||
@@ -251,8 +23,6 @@ desc.set = (newValue) => set(proxyObject, newValue); | ||
| }); | ||
| const proxyObject = proxy(initialObject); | ||
| const proxyObject = proxy.proxy(initialObject); | ||
| return proxyObject; | ||
| } | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| proxyWithComputed | ||
| }); | ||
| exports.proxyWithComputed = proxyWithComputed; |
@@ -7,12 +7,11 @@ type AsRef = { | ||
| type AnyFunction = (...args: any[]) => any; | ||
| type Snapshot<T> = T extends AnyFunction ? T : T extends AsRef ? T : T extends Promise<any> ? Awaited<T> : { | ||
| export type Snapshot<T> = T extends AnyFunction ? T : T extends AsRef ? T : T extends Promise<any> ? Awaited<T> : { | ||
| readonly [K in keyof T]: Snapshot<T[K]>; | ||
| }; | ||
| type HandlePromise = <P extends Promise<any>>(promise: P) => Awaited<P>; | ||
| declare function proxy<T extends object>(initialObject?: T): T; | ||
| declare function getVersion(proxyObject: unknown): number | undefined; | ||
| declare function subscribe<T extends object>(proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean): () => void; | ||
| declare function snapshot<T extends object>(proxyObject: T, handlePromise?: HandlePromise): Snapshot<T>; | ||
| declare function ref<T extends object>(obj: T): T & AsRef; | ||
| export { Snapshot, getVersion, proxy, ref, snapshot, subscribe }; | ||
| export declare function proxy<T extends object>(initialObject?: T): T; | ||
| export declare function getVersion(proxyObject: unknown): number | undefined; | ||
| export declare function subscribe<T extends object>(proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean): () => void; | ||
| export declare function snapshot<T extends object>(proxyObject: T, handlePromise?: HandlePromise): Snapshot<T>; | ||
| export declare function ref<T extends object>(obj: T): T & AsRef; | ||
| export {}; |
@@ -1,36 +0,12 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| // src/proxy.ts | ||
| var proxy_exports = {}; | ||
| __export(proxy_exports, { | ||
| getVersion: () => getVersion, | ||
| proxy: () => proxy, | ||
| ref: () => ref, | ||
| snapshot: () => snapshot, | ||
| subscribe: () => subscribe | ||
| }); | ||
| module.exports = __toCommonJS(proxy_exports); | ||
| var import_proxy_compare = require("proxy-compare"); | ||
| var isDev = process.env.NODE_ENV !== "production"; | ||
| var isObject = (x) => typeof x === "object" && x !== null; | ||
| var proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
| var refSet = /* @__PURE__ */ new WeakSet(); | ||
| var buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in 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), defaultHandlePromise = (promise) => { | ||
| Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); | ||
| const proxyCompare = require('proxy-compare'); | ||
| const isDev = process.env.NODE_ENV !== "production"; | ||
| const isObject = (x) => typeof x === "object" && x !== null; | ||
| const proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
| const refSet = /* @__PURE__ */ new WeakSet(); | ||
| const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in 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), defaultHandlePromise = (promise) => { | ||
| switch (promise.status) { | ||
@@ -50,3 +26,3 @@ case "fulfilled": | ||
| const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
| (0, import_proxy_compare.markToTrack)(snap, true); | ||
| proxyCompare.markToTrack(snap, true); | ||
| snapCache.set(target, [version, snap]); | ||
@@ -56,3 +32,3 @@ Reflect.ownKeys(target).forEach((key) => { | ||
| if (refSet.has(value)) { | ||
| (0, import_proxy_compare.markToTrack)(value, false); | ||
| proxyCompare.markToTrack(value, false); | ||
| snap[key] = value; | ||
@@ -168,7 +144,6 @@ } else if (value instanceof Promise) { | ||
| if (isObject(value)) { | ||
| value = (0, import_proxy_compare.getUntracked)(value) || value; | ||
| value = proxyCompare.getUntracked(value) || value; | ||
| } | ||
| let nextValue = value; | ||
| if (Object.getOwnPropertyDescriptor(target, prop)?.set) { | ||
| } else if (value instanceof Promise) { | ||
| if (Object.getOwnPropertyDescriptor(target, prop)?.set) ; else if (value instanceof Promise) { | ||
| value.then((v) => { | ||
@@ -226,10 +201,6 @@ value.status = "fulfilled"; | ||
| ]; | ||
| var [proxyFunction] = buildProxyFunction(); | ||
| const [proxyFunction] = buildProxyFunction(); | ||
| function proxy(initialObject = {}) { | ||
| return proxyFunction(initialObject); | ||
| } | ||
| function getVersion(proxyObject) { | ||
| const proxyState = proxyStateMap.get(proxyObject); | ||
| return proxyState?.[1](); | ||
| } | ||
| function subscribe(proxyObject, callback, notifyInSync) { | ||
@@ -278,9 +249,6 @@ const proxyState = proxyStateMap.get(proxyObject); | ||
| } | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| getVersion, | ||
| proxy, | ||
| ref, | ||
| snapshot, | ||
| subscribe | ||
| }); | ||
| exports.proxy = proxy; | ||
| exports.ref = ref; | ||
| exports.snapshot = snapshot; | ||
| exports.subscribe = subscribe; |
@@ -1,4 +0,2 @@ | ||
| type CompareFn<T = any> = (prev: T, next: T) => boolean; | ||
| declare function subscribeKey<T extends object, K extends keyof T>(obj: T, key: K, fn: (value: T[K]) => void, sync?: boolean, compareFn?: (prev: T[K], next: T[K]) => boolean): () => void; | ||
| export { CompareFn, subscribeKey }; | ||
| export type CompareFn<T = any> = (prev: T, next: T) => boolean; | ||
| export declare function subscribeKey<T extends object, K extends keyof T>(obj: T, key: K, fn: (value: T[K]) => void, sync?: boolean, compareFn?: (prev: T[K], next: T[K]) => boolean): () => void; |
@@ -1,272 +0,13 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| // src/subscribe-key.ts | ||
| var subscribe_key_exports = {}; | ||
| __export(subscribe_key_exports, { | ||
| subscribeKey: () => subscribeKey | ||
| }); | ||
| module.exports = __toCommonJS(subscribe_key_exports); | ||
| Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); | ||
| // src/proxy.ts | ||
| var import_proxy_compare = require("proxy-compare"); | ||
| var isDev = process.env.NODE_ENV !== "production"; | ||
| var isObject = (x) => typeof x === "object" && x !== null; | ||
| var proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
| var refSet = /* @__PURE__ */ new WeakSet(); | ||
| var buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in 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), defaultHandlePromise = (promise) => { | ||
| switch (promise.status) { | ||
| case "fulfilled": | ||
| return promise.value; | ||
| case "rejected": | ||
| throw promise.reason; | ||
| default: | ||
| throw promise; | ||
| } | ||
| }, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => { | ||
| const cache = snapCache.get(target); | ||
| if (cache?.[0] === version) { | ||
| return cache[1]; | ||
| } | ||
| const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
| (0, import_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, import_proxy_compare.markToTrack)(value, false); | ||
| snap[key] = value; | ||
| } else if (value instanceof Promise) { | ||
| Object.defineProperty(snap, key, { | ||
| get() { | ||
| return handlePromise(value); | ||
| } | ||
| }); | ||
| } else if (proxyStateMap.has(value)) { | ||
| snap[key] = snapshot(value, handlePromise); | ||
| } else { | ||
| snap[key] = value; | ||
| } | ||
| }); | ||
| return Object.freeze(snap); | ||
| }, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction2 = (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 handler = { | ||
| 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, import_proxy_compare.getUntracked)(value) || value; | ||
| } | ||
| let nextValue = value; | ||
| if (Object.getOwnPropertyDescriptor(target, prop)?.set) { | ||
| } else if (value instanceof Promise) { | ||
| value.then((v) => { | ||
| value.status = "fulfilled"; | ||
| value.value = v; | ||
| notifyUpdate(["resolve", [prop], v]); | ||
| }).catch((e) => { | ||
| value.status = "rejected"; | ||
| value.reason = e; | ||
| notifyUpdate(["reject", [prop], e]); | ||
| }); | ||
| } 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; | ||
| } | ||
| }; | ||
| const proxyObject = newProxy(baseObject, handler); | ||
| 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; | ||
| }) => [ | ||
| // public functions | ||
| proxyFunction2, | ||
| // shared state | ||
| proxyStateMap, | ||
| refSet, | ||
| // internal things | ||
| objectIs, | ||
| newProxy, | ||
| canProxy, | ||
| defaultHandlePromise, | ||
| snapCache, | ||
| createSnapshot, | ||
| proxyCache, | ||
| versionHolder | ||
| ]; | ||
| var [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, handlePromise) { | ||
| const proxyState = proxyStateMap.get(proxyObject); | ||
| if (isDev && !proxyState) { | ||
| console.warn("Please use proxy object"); | ||
| } | ||
| const [target, ensureVersion, createSnapshot] = proxyState; | ||
| return createSnapshot(target, ensureVersion(), handlePromise); | ||
| } | ||
| const proxy = require('./proxy.js'); | ||
| // src/subscribe-key.ts | ||
| var defaultCompareFn = (prev, next) => Object.is(prev, next); | ||
| const defaultCompareFn = (prev, next) => Object.is(prev, next); | ||
| function subscribeKey(obj, key, fn, sync, compareFn) { | ||
| let prev = Reflect.get(snapshot(obj), key); | ||
| let prev = Reflect.get(proxy.snapshot(obj), key); | ||
| const isEqual = compareFn || defaultCompareFn; | ||
| function onSnapshotChange() { | ||
| const snap = snapshot(obj); | ||
| const snap = proxy.snapshot(obj); | ||
| if (isEqual(prev, snap[key])) | ||
@@ -277,7 +18,5 @@ return; | ||
| } | ||
| return subscribe(obj, onSnapshotChange, sync); | ||
| return proxy.subscribe(obj, onSnapshotChange, sync); | ||
| } | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| subscribeKey | ||
| }); | ||
| exports.subscribeKey = subscribeKey; |
| { | ||
| "name": "@zag-js/store", | ||
| "version": "0.0.0-dev-20230601120732", | ||
| "version": "0.0.0-dev-20230605130234", | ||
| "description": "The reactive store package for zag machines", | ||
@@ -45,5 +45,3 @@ "keywords": [ | ||
| "scripts": { | ||
| "build-fast": "tsup src", | ||
| "start": "pnpm build --watch", | ||
| "build": "tsup src --dts", | ||
| "build": "vite build -c ../../vite.config.ts", | ||
| "test": "jest --config ../../../jest.config.js --rootDir tests", | ||
@@ -50,0 +48,0 @@ "lint": "eslint src --ext .ts,.tsx", |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Number of low supply chain risk alerts
- decreased by-50%
3
Worsened metrics
- Total package byte prevSize
- decreased by-44.16%
37126
- Number of package files
- decreased by-13.64%
19
- Lines of code
- decreased by-48.03%
977
- Number of medium supply chain risk alerts
- increased byInfinity%
1
No dependency changes