{"version":3,"file":"onek.mjs","sources":["../src/core/constants.ts","../src/core/schedulers/subscribersCheck.ts","../src/core/schedulers/reaction.ts","../src/core/configure.ts","../src/core/subscriber.ts","../src/core/transaction.ts","../src/core/classes/revision.ts","../src/core/classes/common.ts","../src/core/classes/computed.ts","../src/core/classes/observable.ts","../src/core/classes/reaction.ts","../src/core/utils/shallowEquals.ts"],"sourcesContent":["export const enum State {\n    NOT_INITIALIZED,\n    COMPUTING,\n    CLEAN,\n    PASSIVE,\n    DIRTY,\n    DESTROYED,\n}\n\nexport const MAX_REACTION_ITERATIONS = 1000;\n","import { Computed } from \"../classes\";\n\nexport const subscribersCheckQueue: Set<Computed> = new Set();\n\nexport function scheduleSubscribersCheck(computed: Computed) {\n    subscribersCheckQueue.add(computed);\n}\n\nexport function runSubscribersCheck() {\n    subscribersCheckQueue.forEach((computed) => {\n        // the computed might be re-introduced later to the queue\n        // when other checks will be done, so we need to delete it\n        subscribersCheckQueue.delete(computed);\n        computed._checkAndPassivate();\n    });\n    subscribersCheckQueue.clear();\n}\n","import { Reaction } from \"../classes\";\nimport { MAX_REACTION_ITERATIONS } from \"../constants\";\nimport { runSubscribersCheck } from \"./subscribersCheck\";\n\nlet reactionQueue: Array<Reaction> = [];\nlet isReactionRunScheduled = false;\n\nlet reactionScheduler = (runner: () => void) => {\n    Promise.resolve().then(runner).catch(reactionExceptionHandler);\n};\nlet reactionExceptionHandler = (exception: any) => {\n    console.error(\"Reaction exception:\", exception);\n};\n\nexport function setReactionScheduler(scheduler: typeof reactionScheduler) {\n    reactionScheduler = scheduler;\n}\n\nexport function setReactionExceptionHandler(handler: typeof reactionExceptionHandler) {\n    reactionExceptionHandler = handler;\n}\n\nexport function scheduleReaction(reaction: Reaction) {\n    reactionQueue.push(reaction);\n}\n\nfunction runReactions(): void {\n    try {\n        let i = MAX_REACTION_ITERATIONS;\n        while ((reactionQueue.length) && --i) {\n            const reactions = reactionQueue;\n            reactionQueue = [];\n            reactions.forEach((reaction) => {\n                try {\n                    reaction.runManager();\n                } catch (exception: any) {\n                    reactionExceptionHandler(exception);\n                }\n            });\n        }\n        if (!i) {\n            throw new Error(\"Infinite reactions loop\");\n        }\n    } finally {\n        isReactionRunScheduled = false;\n        reactionQueue = [];\n\n        runSubscribersCheck();\n    }\n}\n\nexport function scheduleReactionRunner(): void {\n    const shouldRunReactions = reactionQueue.length;\n\n    if (!isReactionRunScheduled && shouldRunReactions) {\n        isReactionRunScheduled = true;\n        reactionScheduler(runReactions);\n    }\n}\n","import { IOptions } from \"./types\";\nimport { setReactionExceptionHandler, setReactionScheduler } from \"./schedulers\";\n\nexport function configure(options: IOptions) {\n    if (options.reactionScheduler) {\n        setReactionScheduler(options.reactionScheduler);\n    }\n    if (options.reactionExceptionHandler) {\n        setReactionExceptionHandler(options.reactionExceptionHandler);\n    }\n}\n","import type { MaybeSubscriber } from \"./types\";\n\nexport let subscriber: MaybeSubscriber = null;\n\nexport function setSubscriber(newSubscriber: MaybeSubscriber): MaybeSubscriber {\n    const oldSubscriber = subscriber;\n\n    subscriber = newSubscriber;\n\n    return oldSubscriber;\n}\n","import { IdentityFn, MaybeSubscriber } from \"./types\";\nimport { setSubscriber } from \"./subscriber\";\nimport { scheduleReactionRunner } from \"./schedulers\";\n\nlet txDepth = 0;\n\nexport function tx(fn: () => void): void {\n    txDepth += 1;\n    try {\n        fn();\n    } finally {\n        txDepth -= 1;\n        endTx();\n    }\n}\n\nexport function utx<T>(fn: () => T, subscriber: MaybeSubscriber = null): T {\n    const oldSubscriber = setSubscriber(subscriber);\n    txDepth += 1;\n    try {\n        return fn();\n    } finally {\n        txDepth -= 1;\n        setSubscriber(oldSubscriber);\n        endTx();\n    }\n}\n\nexport function untracked<T>(fn: () => T): T {\n    const oldSubscriber = setSubscriber(null);\n    try {\n        return fn();\n    } finally {\n        setSubscriber(oldSubscriber);\n    }\n}\n\nexport function withUntracked<T extends Function>(fn: T): IdentityFn<T> {\n    return function (this: any) {\n        const oldSubscriber = setSubscriber(null);\n        try {\n            return fn.apply(this, arguments as any);\n        } finally {\n            setSubscriber(oldSubscriber);\n        }\n    } as IdentityFn<T>;\n}\n\nexport function action<T extends Function>(fn: T): IdentityFn<T> {\n    return function (this: any) {\n        const oldSubscriber = setSubscriber(null);\n        txDepth += 1;\n        try {\n            return fn.apply(this, arguments as any);\n        } finally {\n            txDepth -= 1;\n            setSubscriber(oldSubscriber);\n            endTx();\n        }\n    } as IdentityFn<T>;\n}\n\nexport function endTx() {\n    if (!txDepth) {\n        scheduleReactionRunner();\n    }\n}\n","import type { IRevision } from \"../types\";\n\nlet revisionId = 0;\n\nexport class Revision implements IRevision {\n    // nothing here\n\n    public id = revisionId++;\n}\n","import { ISubscriber, ISubscription } from \"../types\";\nimport { Revision } from \"./revision\";\n\nexport function checkRevisions(subscriptions: Map<ISubscription, Revision>) {\n    let revisionsChanged = false;\n\n    subscriptions.forEach((revision, subscription) => {\n        revisionsChanged ||= subscription._getRevision() !== revision;\n    });\n\n    return revisionsChanged;\n}\n\nexport function unsubscribe(\n    subscriptions: Map<ISubscription, Revision>,\n    subscriber: ISubscriber\n): void {\n    subscriptions.forEach((_revision, subscription) => {\n        subscription._removeSubscriber(subscriber);\n    });\n}\n\nexport function subscribe(\n    subscriptions: Map<ISubscription, Revision>,\n    subscriber: ISubscriber\n): void {\n    subscriptions.forEach((_revision, subscription) => {\n        subscription._addSubscriber(subscriber);\n    });\n}\n\nexport function notify(subscribers: Set<ISubscriber>): void {\n    subscribers.forEach((subscriber) => {\n        subscriber._notify();\n    });\n}\n","import type {\n    CheckFn,\n    IComputed,\n    IComputedGetter,\n    IComputedImpl,\n    IRevision,\n    ISubscriber,\n    ISubscription,\n} from \"../types\";\nimport { State } from \"../constants\";\nimport { setSubscriber, subscriber } from \"../subscriber\";\nimport { scheduleSubscribersCheck } from \"../schedulers\";\nimport { withUntracked } from \"../transaction\";\nimport { Revision } from \"./revision\";\nimport { checkRevisions, notify, subscribe, unsubscribe } from \"./common\";\n\ntype ComputedState = State.CLEAN | State.NOT_INITIALIZED | State.COMPUTING | State.DIRTY;\n\nexport class Computed<T = any> implements IComputedImpl<T> {\n    private _value: T | undefined = undefined;\n    private _revision: IRevision = new Revision();\n    private readonly _subscribers: Set<ISubscriber> = new Set();\n    private readonly _subscriptions: Map<ISubscription, IRevision> = new Map();\n    private _state: ComputedState = State.NOT_INITIALIZED;\n\n    private declare readonly _fn: () => T;\n    private declare readonly _checkFn: CheckFn<T>;\n\n    constructor(fn: () => T, checkFn: CheckFn<T> = Object.is) {\n        this._fn = fn;\n        this._checkFn = withUntracked(checkFn);\n    }\n\n    addSubscription(subscription: ISubscription): void {\n        this._subscriptions.set(subscription, subscription._getRevision());\n\n        if (this._subscribers.size) {\n            subscription._addSubscriber(this);\n        }\n    }\n\n    _addSubscriber(subscriber: ISubscriber): void {\n        if (!this._subscribers.size) {\n            subscribe(this._subscriptions, this);\n        }\n\n        this._subscribers.add(subscriber);\n    }\n\n    _removeSubscriber(subscriber: ISubscriber): void {\n        this._subscribers.delete(subscriber);\n\n        if (!this._subscribers.size) {\n            scheduleSubscribersCheck(this);\n        }\n    }\n\n    _checkAndPassivate(): void {\n        if (!this._subscribers.size) {\n            unsubscribe(this._subscriptions, this);\n            this._state = State.DIRTY;\n        }\n    }\n\n    _notify() {\n        unsubscribe(this._subscriptions, this);\n        notify(this._subscribers);\n        this._state = State.DIRTY;\n    }\n\n    _getRevision(): IRevision {\n        if (this._state === State.NOT_INITIALIZED) {\n            this._value = this._recompute();\n        }\n\n        if (this._state === State.DIRTY) {\n            if (checkRevisions(this._subscriptions)) {\n                let result = this._recompute();\n\n                if (!this._checkFn(this._value!, result)) {\n                    this._value = result;\n                    this._revision = new Revision();\n                }\n            } else if (this._subscribers.size) {\n                subscribe(this._subscriptions, this);\n            }\n        }\n\n        this._state = this._subscribers.size ? State.CLEAN : State.DIRTY;\n\n        return this._revision;\n    }\n\n    _recompute(): T {\n        unsubscribe(this._subscriptions, this);\n\n        this._subscriptions.clear();\n        this._state = State.COMPUTING;\n\n        const oldSubscriber = setSubscriber(this);\n\n        try {\n            return this._fn();\n        } catch (err) {\n            this.destroy();\n\n            throw err;\n        } finally {\n            setSubscriber(oldSubscriber);\n        }\n    }\n\n    destroy(): void {\n        unsubscribe(this._subscriptions, this);\n        this._subscriptions.clear();\n        this._state = State.NOT_INITIALIZED;\n        this._value = undefined;\n    }\n\n    get(_subscriber = subscriber): T {\n        if (this._state === State.COMPUTING) {\n            throw new Error(\"Recursive computed call\");\n        }\n\n        if (_subscriber) {\n            _subscriber.addSubscription(this);\n        }\n\n        this._getRevision();\n\n        return this._value!;\n    }\n}\n\nexport function computed<T>(fn: () => T, checkFn?: CheckFn<T>): IComputedGetter<T> {\n    const comp = new Computed(fn, checkFn);\n    const get = comp.get.bind(comp) as IComputedGetter<T>;\n\n    get.instance = comp;\n    get.destroy = comp.destroy.bind(comp);\n    get.revision = comp._getRevision.bind(comp);\n\n    return get;\n}\n\ncomputed.box = <T>(fn: () => T, checkFn?: CheckFn<T>): IComputed<T> => {\n    return new Computed(fn, checkFn);\n};\n\ncomputed.prop = <T>(fn: () => T, checkFn?: CheckFn<T>): T => {\n    return new Computed(fn, checkFn) as unknown as T;\n};\n","import type {\n    CheckFn,\n    IObservable,\n    IObservableGetter,\n    IObservableImpl,\n    IRevision,\n    ISetter,\n    ISubscriber,\n    UpdaterFn,\n} from \"../types\";\nimport { State } from \"../constants\";\nimport { Computed } from \"./computed\";\nimport { Revision } from \"./revision\";\nimport { subscriber } from \"../subscriber\";\nimport { endTx, withUntracked } from \"../transaction\";\nimport { notify } from \"./common\";\n\nexport class Observable<T = any> implements IObservableImpl<T> {\n    private _revision: IRevision = new Revision();\n    private _subscribers: Set<ISubscriber> = new Set();\n\n    private declare _value: T;\n    private declare readonly _checkFn: CheckFn<T>;\n\n    constructor(value: T, checkFn = Object.is) {\n        this._value = value;\n        this._checkFn = withUntracked(checkFn);\n    }\n\n    _addSubscriber(subscriber: ISubscriber): void {\n        this._subscribers.add(subscriber);\n    }\n\n    _removeSubscriber(subscriber: ISubscriber): void {\n        this._subscribers.delete(subscriber);\n    }\n\n    _getRevision(): IRevision {\n        return this._revision;\n    }\n\n    get(_subscriber = subscriber): T {\n        if (_subscriber) {\n            _subscriber.addSubscription(this);\n        }\n        \n        return this._value;\n    }\n\n    set(newValue?: T | UpdaterFn<T>, asIs?: boolean): void {\n        if (subscriber && subscriber instanceof Computed) {\n            throw new Error(\"Changing observable inside of computed\");\n        }\n\n        if (arguments.length > 0) {\n            if (typeof newValue === \"function\" && !asIs) {\n                newValue = (newValue as UpdaterFn<T>)(this._value);\n            }\n\n            if (this._checkFn(this._value, newValue as T)) {\n                return;\n            }\n\n            this._value = newValue as T;\n        }\n\n        this.notify();\n    }\n\n    notify(): void {\n        this._revision = new Revision();\n\n        notify(this._subscribers);\n        endTx();\n    }\n}\n\nexport function observable<T>(value: T, checkFn?: CheckFn<T>) {\n    const obs = new Observable(value, checkFn);\n    const get = obs.get.bind(obs) as IObservableGetter<T>;\n    const set = obs.set.bind(obs) as ISetter<T>;\n\n    get.instance = obs;\n    get.revision = obs._getRevision.bind(obs);\n\n    return [get, set] as const;\n}\n\nobservable.box = <T>(value: T, checkFn?: CheckFn<T>): IObservable<T> => {\n    return new Observable(value, checkFn);\n};\n\nobservable.prop = <T>(value: T, checkFn?: CheckFn<T>): T => {\n    return new Observable(value, checkFn) as unknown as T;\n};\n","import type {\n    Destructor,\n    Disposer,\n    IReactionImpl,\n    IRevision,\n    ReactionFn,\n    ISubscription,\n} from \"../types\";\nimport { State } from \"../constants\";\nimport { scheduleReaction } from \"../schedulers\";\nimport { utx } from \"../transaction\";\nimport { checkRevisions, subscribe, unsubscribe } from \"./common\";\n\ntype ReactionState = State.CLEAN | State.DIRTY | State.DESTROYED;\n\nexport class Reaction implements IReactionImpl {\n    public shouldSubscribe = true;\n\n    private _subscriptions: Map<ISubscription, IRevision> = new Map();\n    private _destructor: Destructor = null;\n    private _state: ReactionState = State.CLEAN;\n\n    constructor(private _fn: ReactionFn, private _manager?: () => void) {}\n\n    addSubscription(subscription: ISubscription): void {\n        if (this.shouldSubscribe) {\n            subscription._addSubscriber(this);\n        }\n\n        this._subscriptions.set(subscription, subscription._getRevision());\n    }\n\n    _notify(): void {\n        if (this._state === State.CLEAN) {\n            this._state = State.DIRTY;\n            scheduleReaction(this);\n        }\n    }\n\n    runManager(): void {\n        const revisionsChanged = checkRevisions(this._subscriptions);\n\n        if (!revisionsChanged) {\n            this._state = State.CLEAN;\n            \n            return;\n        }\n\n        if (this._manager) {\n            this._manager();\n        } else {\n            this.run();\n        }\n    }\n\n    subscribe(): void {\n        subscribe(this._subscriptions, this);\n    }\n\n    unsubscribe(): void {\n        unsubscribe(this._subscriptions, this);\n    }\n\n    unsubscribeAndCleanup(): void {\n        this.unsubscribe();\n        this._subscriptions.clear();\n        this._destructor && this._destructor();\n        this._destructor = null;\n        this._state = State.CLEAN;\n    }\n\n    missedRun(): boolean {\n        return checkRevisions(this._subscriptions);\n    }\n\n    destroy(): void {\n        this.unsubscribeAndCleanup();\n        this._state = State.DESTROYED;\n    }\n\n    run(): void {\n        this.unsubscribeAndCleanup();\n\n        utx(this._runnerFn, this);\n    }\n\n    updateRevisions(): void {\n        this._subscriptions.forEach((revision, subscription) => {\n            this._subscriptions.set(subscription, subscription._getRevision());\n        });\n    }\n\n    private _runnerFn = () => {\n        this._destructor = this._fn();\n    };\n}\n\nexport function reaction(fn: ReactionFn, manager?: () => void): Disposer {\n    const r = new Reaction(fn, manager);\n    const destructor = r.destroy.bind(r) as Disposer;\n    destructor.run = r.run.bind(r);\n\n    r.run();\n\n    return destructor;\n}\n","import { withUntracked } from \"../transaction\";\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction isPlainObject(obj: any): obj is Object {\n    return obj.constructor === Object || obj.constructor === null;\n}\n\nexport function shallowEquals<T>(prev: T, next: T): boolean {\n    if (prev === next) {\n        return true;\n    }\n\n    if (Array.isArray(prev) && Array.isArray(next)) {\n        let idx = prev.length;\n\n        if (idx !== next.length) {\n            return false;\n        }\n\n        while (idx--) {\n            if (prev[idx] !== next[idx]) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    if (\n        prev &&\n        next &&\n        typeof prev === \"object\" &&\n        typeof next === \"object\" &&\n        isPlainObject(prev) &&\n        isPlainObject(next)\n    ) {\n        const prevKeys = Object.keys(prev);\n\n        let index = prevKeys.length;\n\n        if (Object.keys(next).length !== index) {\n            return false;\n        }\n\n        while (index-- > 0) {\n            let key = prevKeys[index];\n\n            // @ts-ignore\n            if (!hasOwnProperty.call(next, key) || prev[key] !== next[key]) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    if (prev instanceof Set && next instanceof Set) {\n        if (prev.size !== next.size) {\n            return false;\n        }\n\n        let result = true;\n\n        prev.forEach((value) => {\n            if (!next.has(value)) {\n                result = false;\n            }\n        });\n\n        return result;\n    }\n\n    if (prev instanceof Map && next instanceof Map) {\n        if (prev.size !== next.size) {\n            return false;\n        }\n\n        let result = true;\n\n        prev.forEach((value, key) => {\n            if (next.get(key) !== value) {\n                result = false;\n            }\n        });\n\n        return result;\n    }\n\n    return false;\n}\n\nexport const untrackedShallowEquals = withUntracked(shallowEquals);\n"],"names":["MAX_REACTION_ITERATIONS","subscribersCheckQueue","Set","reactionQueue","isReactionRunScheduled","reactionScheduler","runner","Promise","resolve","then","catch","reactionExceptionHandler","exception","console","error","runReactions","i","length","reactions","forEach","reaction","runManager","Error","computed","delete","_checkAndPassivate","clear","configure","options","subscriber","setSubscriber","newSubscriber","oldSubscriber","txDepth","tx","fn","endTx","utx","untracked","withUntracked","apply","this","arguments","action","revisionId","Revision","constructor","id","checkRevisions","subscriptions","revisionsChanged","revision","subscription","_getRevision","unsubscribe","_revision","_removeSubscriber","subscribe","_addSubscriber","notify","subscribers","_notify","Computed","checkFn","Object","is","_value","undefined","_subscribers","_subscriptions","Map","_state","_fn","_checkFn","addSubscription","set","size","add","scheduleSubscribersCheck","_recompute","result","err","destroy","get","_subscriber","comp","bind","instance","box","prop","Observable","value","newValue","asIs","observable","obs","Reaction","_manager","shouldSubscribe","_destructor","_runnerFn","push","scheduleReaction","run","unsubscribeAndCleanup","missedRun","updateRevisions","manager","r","destructor","hasOwnProperty","prototype","isPlainObject","obj","shallowEquals","prev","next","Array","isArray","idx","prevKeys","keys","index","key","call","has"],"mappings":"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"}