Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363import { getUntracked, markToTrack } from 'proxy-compare'
const isObject = (x: unknown): x is object => typeof x === 'object' && x !== null
type AnyFunction = (...args: any[]) => any
type ProxyObject = object
type Path = (string | symbol)[]type Op = | [op: 'set', path: Path, value: unknown, prevValue: unknown] | [op: 'delete', path: Path, prevValue: unknown] | [op: 'resolve', path: Path, value: unknown] | [op: 'reject', path: Path, error: unknown]type Listener = (op: Op, nextVersion: number) => void
type Primitive = string | number | boolean | null | undefined | symbol | bigint
type SnapshotIgnore = | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Error | RegExp | AnyFunction | Primitive
export type Snapshot<T> = T extends { $$valtioSnapshot: infer S } ? S : T extends SnapshotIgnore ? T : T extends object ? { readonly [K in keyof T]: Snapshot<T[K]> } : T
type CreateSnapshot = <T extends object>(target: T, version: number) => T
type RemoveListener = () => voidtype AddListener = (listener: Listener) => RemoveListener
type ProxyState = readonly [ target: object, ensureVersion: (nextCheckVersion?: number) => number, createSnapshot: CreateSnapshot, addListener: AddListener,]
// shared stateconst proxyStateMap = new WeakMap<ProxyObject, ProxyState>()const refSet = new WeakSet()
const buildProxyFunction = ( objectIs = Object.is,
newProxy = <T extends object>(target: T, handler: ProxyHandler<T>): T => new Proxy(target, handler),
canProxy = (x: unknown) => 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),
snapCache = new WeakMap<object, [version: number, snap: unknown]>(),
createSnapshot: CreateSnapshot = <T extends object>( target: T, version: number, ): T => { const cache = snapCache.get(target) if (cache?.[0] === version) { return cache[1] as T } const snap: any = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)) markToTrack(snap, true) // mark to track snapCache.set(target, [version, snap]) Reflect.ownKeys(target).forEach((key) => { if (Object.getOwnPropertyDescriptor(snap, key)) { // Only the known case is Array.length so far. return } const value = Reflect.get(target, key) const { enumerable } = Reflect.getOwnPropertyDescriptor( target, key, ) as PropertyDescriptor const desc: PropertyDescriptor = { value, enumerable: enumerable as boolean, // This is intentional to avoid copying with proxy-compare. // It's still non-writable, so it avoids assigning a value. configurable: true, } if (refSet.has(value as object)) { markToTrack(value as object, false) // mark not to track } else if (proxyStateMap.has(value as object)) { const [target, ensureVersion] = proxyStateMap.get( value as object, ) as ProxyState desc.value = createSnapshot(target, ensureVersion()) as Snapshot<T> } Object.defineProperty(snap, key, desc) }) return Object.preventExtensions(snap) },
proxyCache = new WeakMap<object, ProxyObject>(),
versionHolder = [1, 1] as [number, number],
proxyFunction = <T extends object>(baseObject: T): T => { if (!isObject(baseObject)) { throw new Error('object required') } const found = proxyCache.get(baseObject) as T | undefined if (found) { return found } let version = versionHolder[0] const listeners = new Set<Listener>() const notifyUpdate = (op: 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: string | symbol): Listener => (op, nextVersion) => { const newOp: Op = [...op] newOp[1] = [prop, ...(newOp[1] as Path)] notifyUpdate(newOp, nextVersion) } const propProxyStates = new Map< string | symbol, readonly [ProxyState, RemoveListener?] >() const addPropListener = (prop: string | symbol, propValue: unknown) => { const propProxyState = !refSet.has(propValue as object) && proxyStateMap.get(propValue as object) if (propProxyState) { if ( import.meta.env?.MODE !== 'production' && 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: string | symbol) => { const entry = propProxyStates.get(prop) if (entry) { propProxyStates.delete(prop) entry[1]?.() } } const addListener = (listener: Listener) => { listeners.add(listener) if (listeners.size === 1) { propProxyStates.forEach(([propProxyState, prevRemove], prop) => { if (import.meta.env?.MODE !== 'production' && 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 } let initializing = true const handler: ProxyHandler<T> = { deleteProperty(target: T, prop: string | symbol) { const prevValue = Reflect.get(target, prop) removePropListener(prop) const deleted = Reflect.deleteProperty(target, prop) if (deleted) { notifyUpdate(['delete', [prop], prevValue]) } return deleted }, set(target: T, prop: string | symbol, value: any, receiver: object) { const hasPrevValue = !initializing && 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 (value instanceof Promise) { value .then((v) => { ;(value as any).status = 'fulfilled' ;(value as any).value = v notifyUpdate(['resolve', [prop], v]) }) .catch((e) => { ;(value as any).status = 'rejected' ;(value as any).reason = e notifyUpdate(['reject', [prop], e]) }) } else { if (!proxyStateMap.has(value) && canProxy(value)) { nextValue = proxyFunction(value) } addPropListener(prop, nextValue) } Reflect.set(target, prop, nextValue, receiver) notifyUpdate(['set', [prop], value, prevValue]) return true }, } const proxyObject = newProxy(baseObject, handler) proxyCache.set(baseObject, proxyObject) const proxyState: ProxyState = [ baseObject, ensureVersion, createSnapshot, addListener, ] proxyStateMap.set(proxyObject, proxyState) Reflect.ownKeys(baseObject).forEach((key) => { const desc = Object.getOwnPropertyDescriptor( baseObject, key, ) as PropertyDescriptor if ('value' in desc && desc.writable) { proxyObject[key as keyof T] = baseObject[key as keyof T] } }) initializing = false return proxyObject },) => [ // public functions proxyFunction, // shared state proxyStateMap, refSet, // internal things objectIs, newProxy, canProxy, snapCache, createSnapshot, proxyCache, versionHolder, ] as const
const [defaultProxyFunction] = buildProxyFunction()
export function proxy<T extends object>(baseObject: T = {} as T): T { return defaultProxyFunction(baseObject)}
export function getVersion(proxyObject: unknown): number | undefined { const proxyState = proxyStateMap.get(proxyObject as object) return proxyState?.[1]()}
export function subscribe<T extends object>( proxyObject: T, callback: (ops: Op[]) => void, notifyInSync?: boolean,): () => void { const proxyState = proxyStateMap.get(proxyObject as object) if (import.meta.env?.MODE !== 'production' && !proxyState) { console.warn('Please use proxy object') } let promise: Promise<void> | undefined const ops: Op[] = [] const addListener = (proxyState as ProxyState)[3] let isListenerActive = false const listener: Listener = (op) => { ops.push(op) if (notifyInSync) { callback(ops.splice(0)) return } if (!promise) { promise = Promise.resolve().then(() => { promise = undefined if (isListenerActive) { callback(ops.splice(0)) } }) } } const removeListener = addListener(listener) isListenerActive = true return () => { isListenerActive = false removeListener() }}
export function snapshot<T extends object>(proxyObject: T): Snapshot<T> { const proxyState = proxyStateMap.get(proxyObject as object) if (import.meta.env?.MODE !== 'production' && !proxyState) { console.warn('Please use proxy object') } const [target, ensureVersion, createSnapshot] = proxyState as ProxyState return createSnapshot(target, ensureVersion()) as Snapshot<T>}
export function ref<T extends object>(obj: T) { refSet.add(obj) return obj as T & { $$valtioSnapshot: T }}
export const unstable_buildProxyFunction = buildProxyFunction