@montra-interactive/deepstate 0.1.0

package/dist/index.js

@@ -0,0 +1,750 @@
+// src/helpers.ts
+import { combineLatest } from "rxjs";
+import { distinctUntilChanged, map } from "rxjs/operators";
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+function isObservable(obj) {
+  return obj !== null && typeof obj === "object" && "subscribe" in obj && typeof obj.subscribe === "function";
+}
+function select(...args) {
+  if (args.length === 1 && !isObservable(args[0])) {
+    const obj = args[0];
+    const keys = Object.keys(obj);
+    const observables = keys.map((k) => obj[k]);
+    return combineLatest(observables).pipe(map((values) => {
+      const result = {};
+      keys.forEach((key, i) => {
+        result[key] = values[i];
+      });
+      return result;
+    }));
+  }
+  return combineLatest(args);
+}
+function selectFromEach(arrayNode, selector) {
+  return arrayNode.pipe(map((items) => items.map(selector)), distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => deepEqual(v, b[i]))));
+}
+
+// src/deepstate.ts
+import { BehaviorSubject, combineLatest as combineLatest2, of } from "rxjs";
+import {
+  map as map2,
+  distinctUntilChanged as distinctUntilChanged2,
+  shareReplay,
+  take,
+  filter
+} from "rxjs/operators";
+var distinctCallCount = 0;
+function countedDistinctUntilChanged(compareFn) {
+  return distinctUntilChanged2((a, b) => {
+    distinctCallCount++;
+    if (compareFn)
+      return compareFn(a, b);
+    return a === b;
+  });
+}
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  if (Object.isFrozen(obj))
+    return obj;
+  Object.freeze(obj);
+  if (Array.isArray(obj)) {
+    obj.forEach((item) => deepFreeze(item));
+  } else {
+    Object.keys(obj).forEach((key) => {
+      deepFreeze(obj[key]);
+    });
+  }
+  return obj;
+}
+var NODE = Symbol("node");
+function createLeafNode(value) {
+  const subject$ = new BehaviorSubject(value);
+  const distinct$ = subject$.pipe(distinctUntilChanged2(), shareReplay(1));
+  distinct$.subscribe();
+  return {
+    $: distinct$,
+    get: () => subject$.getValue(),
+    set: (v) => subject$.next(v),
+    subscribeOnce: (callback) => {
+      return distinct$.pipe(take(1)).subscribe(callback);
+    }
+  };
+}
+function createObjectNode(value) {
+  const keys = Object.keys(value);
+  const children = new Map;
+  for (const key of keys) {
+    children.set(key, createNodeForValue(value[key], true));
+  }
+  const getCurrentValue = () => {
+    const result = {};
+    for (const [key, child] of children) {
+      result[key] = child.get();
+    }
+    return result;
+  };
+  if (keys.length === 0) {
+    const empty$ = of(value).pipe(shareReplay(1));
+    return {
+      $: empty$,
+      children,
+      get: () => ({}),
+      set: () => {},
+      lock: () => {},
+      unlock: () => {}
+    };
+  }
+  const lock$ = new BehaviorSubject(true);
+  const childObservables = keys.map((key) => children.get(key).$);
+  const $ = combineLatest2([...childObservables, lock$]).pipe(filter((values) => values[values.length - 1] === true), map2((values) => {
+    const result = {};
+    keys.forEach((key, i) => {
+      result[key] = values[i];
+    });
+    return result;
+  }), shareReplay(1));
+  $.subscribe();
+  const frozen$ = $.pipe(map2(deepFreeze));
+  return {
+    $: frozen$,
+    children,
+    get: () => deepFreeze(getCurrentValue()),
+    set: (v) => {
+      for (const [key, child] of children) {
+        child.set(v[key]);
+      }
+    },
+    lock: () => lock$.next(false),
+    unlock: () => lock$.next(true),
+    subscribeOnce: (callback) => {
+      return frozen$.pipe(take(1)).subscribe(callback);
+    }
+  };
+}
+function createArrayNode(value) {
+  const subject$ = new BehaviorSubject([...value]);
+  const childCache = new Map;
+  const createChildProjection = (index) => {
+    const currentValue = subject$.getValue()[index];
+    if (currentValue !== null && typeof currentValue === "object") {
+      return createArrayElementObjectNode(subject$, index, currentValue);
+    }
+    const element$ = subject$.pipe(map2((arr) => arr[index]), countedDistinctUntilChanged(), shareReplay(1));
+    element$.subscribe();
+    return {
+      $: element$,
+      get: () => subject$.getValue()[index],
+      set: (v) => {
+        const arr = [...subject$.getValue()];
+        arr[index] = v;
+        subject$.next(arr);
+      },
+      subscribeOnce: (callback) => {
+        return element$.pipe(take(1)).subscribe(callback);
+      }
+    };
+  };
+  const lock$ = new BehaviorSubject(true);
+  const locked$ = combineLatest2([subject$, lock$]).pipe(filter(([_, unlocked]) => unlocked), map2(([arr, _]) => arr), map2(deepFreeze), shareReplay(1));
+  locked$.subscribe();
+  const length$ = locked$.pipe(map2((arr) => arr.length), distinctUntilChanged2(), shareReplay(1));
+  length$.subscribe();
+  const lengthWithGet = Object.assign(length$, {
+    get: () => subject$.getValue().length
+  });
+  return {
+    $: locked$,
+    childCache,
+    get: () => deepFreeze([...subject$.getValue()]),
+    set: (v) => {
+      childCache.clear();
+      subject$.next([...v]);
+    },
+    subscribeOnce: (callback) => {
+      return locked$.pipe(take(1)).subscribe(callback);
+    },
+    at: (index) => {
+      const arr = subject$.getValue();
+      if (index < 0 || index >= arr.length)
+        return;
+      if (!childCache.has(index)) {
+        childCache.set(index, createChildProjection(index));
+      }
+      return childCache.get(index);
+    },
+    length$: lengthWithGet,
+    push: (...items) => {
+      const current = subject$.getValue();
+      const newArr = [...current, ...items];
+      subject$.next(newArr);
+      return newArr.length;
+    },
+    pop: () => {
+      const current = subject$.getValue();
+      if (current.length === 0)
+        return;
+      const last = current[current.length - 1];
+      childCache.delete(current.length - 1);
+      subject$.next(current.slice(0, -1));
+      return deepFreeze(last);
+    },
+    mapItems: (fn) => {
+      return subject$.getValue().map((item, i) => fn(deepFreeze(item), i));
+    },
+    filterItems: (fn) => {
+      return deepFreeze(subject$.getValue().filter((item, i) => fn(deepFreeze(item), i)));
+    },
+    lock: () => lock$.next(false),
+    unlock: () => lock$.next(true)
+  };
+}
+var NULLABLE_NODE = Symbol("nullableNode");
+function createNullableObjectNode(initialValue) {
+  const subject$ = new BehaviorSubject(initialValue);
+  let children = null;
+  const pendingChildren = new Map;
+  const lock$ = new BehaviorSubject(true);
+  const buildChildren = (obj) => {
+    const keys = Object.keys(obj);
+    children = new Map;
+    for (const key of keys) {
+      children.set(key, createNodeForValue(obj[key]));
+    }
+  };
+  if (initialValue !== null && initialValue !== undefined && typeof initialValue === "object") {
+    buildChildren(initialValue);
+  }
+  const getCurrentValue = () => {
+    const raw = subject$.getValue();
+    if (raw === null || raw === undefined || !children) {
+      return raw;
+    }
+    const result = {};
+    for (const [key, child] of children) {
+      result[key] = child.get();
+    }
+    return result;
+  };
+  const $ = combineLatest2([subject$, lock$]).pipe(filter(([_, unlocked]) => unlocked), map2(([value, _]) => {
+    if (value === null || value === undefined || !children) {
+      return value;
+    }
+    const result = {};
+    for (const [key, child] of children) {
+      result[key] = child.get();
+    }
+    return result;
+  }), distinctUntilChanged2((a, b) => {
+    if (a === null || a === undefined)
+      return a === b;
+    if (b === null || b === undefined)
+      return false;
+    return JSON.stringify(a) === JSON.stringify(b);
+  }), map2(deepFreeze), shareReplay(1));
+  $.subscribe();
+  const nodeState = { children };
+  const updateChildrenRef = () => {
+    nodeState.children = children;
+  };
+  const buildChildrenAndUpdate = (obj) => {
+    const keys = Object.keys(obj);
+    children = new Map;
+    for (const key of keys) {
+      children.set(key, createNodeForValue(obj[key], true));
+    }
+    updateChildrenRef();
+    for (const [key, pendingNode] of pendingChildren) {
+      if (children.has(key) && "_subscribeToRealChild" in pendingNode) {
+        pendingNode._subscribeToRealChild();
+      }
+    }
+  };
+  if (initialValue !== null && initialValue !== undefined && typeof initialValue === "object") {
+    children = null;
+    buildChildrenAndUpdate(initialValue);
+  }
+  return {
+    [NULLABLE_NODE]: true,
+    $,
+    get children() {
+      return nodeState.children;
+    },
+    get: () => deepFreeze(getCurrentValue()),
+    set: (value) => {
+      if (value === null || value === undefined) {
+        subject$.next(value);
+      } else if (typeof value === "object") {
+        if (!children) {
+          buildChildrenAndUpdate(value);
+        } else {
+          const newKeys = new Set(Object.keys(value));
+          const existingKeys = new Set(children.keys());
+          for (const [key, child] of children) {
+            if (newKeys.has(key)) {
+              child.set(value[key]);
+            }
+          }
+          for (const key of newKeys) {
+            if (!existingKeys.has(key)) {
+              children.set(key, createNodeForValue(value[key], true));
+            }
+          }
+        }
+        subject$.next(value);
+      }
+    },
+    getChild: (key) => {
+      const value = subject$.getValue();
+      if (value === null || value === undefined || !children) {
+        return;
+      }
+      return children.get(key);
+    },
+    getOrCreateChild: (key) => {
+      if (children && children.has(key)) {
+        return children.get(key);
+      }
+      if (pendingChildren.has(key)) {
+        if (children && children.has(key)) {
+          return children.get(key);
+        }
+        return pendingChildren.get(key);
+      }
+      const pendingSubject$ = new BehaviorSubject(undefined);
+      const parentSubscription = subject$.subscribe((parentValue) => {
+        if (parentValue === null || parentValue === undefined) {
+          pendingSubject$.next(undefined);
+        } else if (children && children.has(key)) {
+          pendingSubject$.next(children.get(key).get());
+        } else {
+          pendingSubject$.next(parentValue[key]);
+        }
+      });
+      let realChildSubscription = null;
+      const child$ = pendingSubject$.pipe(distinctUntilChanged2(), shareReplay(1));
+      child$.subscribe();
+      const pendingNode = {
+        $: child$,
+        get: () => {
+          const parentValue = subject$.getValue();
+          if (parentValue === null || parentValue === undefined) {
+            return;
+          }
+          if (children && children.has(key)) {
+            return children.get(key).get();
+          }
+          return parentValue[key];
+        },
+        set: (value) => {
+          const parentValue = subject$.getValue();
+          if (parentValue === null || parentValue === undefined) {
+            return;
+          }
+          if (children && children.has(key)) {
+            children.get(key).set(value);
+            return;
+          }
+          const newParent = { ...parentValue, [key]: value };
+          subject$.next(newParent);
+        },
+        _subscribeToRealChild: () => {
+          if (children && children.has(key) && !realChildSubscription) {
+            realChildSubscription = children.get(key).$.subscribe((value) => {
+              pendingSubject$.next(value);
+            });
+          }
+        }
+      };
+      pendingChildren.set(key, pendingNode);
+      return pendingNode;
+    },
+    isNull: () => {
+      const value = subject$.getValue();
+      return value === null || value === undefined;
+    },
+    lock: () => lock$.next(false),
+    unlock: () => lock$.next(true),
+    subscribeOnce: (callback) => {
+      return $.pipe(take(1)).subscribe(callback);
+    }
+  };
+}
+function isNullableNode(node) {
+  return NULLABLE_NODE in node;
+}
+function createArrayElementObjectNode(parentArray$, index, initialValue) {
+  const keys = Object.keys(initialValue);
+  const children = new Map;
+  for (const key of keys) {
+    children.set(key, createArrayElementPropertyNode(parentArray$, index, key, initialValue[key]));
+  }
+  if (keys.length === 0) {
+    const element$ = parentArray$.pipe(map2((arr) => arr[index]), countedDistinctUntilChanged(), shareReplay(1));
+    element$.subscribe();
+    return {
+      $: element$,
+      children,
+      get: () => parentArray$.getValue()[index],
+      set: (v) => {
+        const arr = [...parentArray$.getValue()];
+        arr[index] = v;
+        parentArray$.next(arr);
+      }
+    };
+  }
+  const childObservables = keys.map((key) => children.get(key).$);
+  const $ = combineLatest2(childObservables).pipe(map2((values) => {
+    const result = {};
+    keys.forEach((key, i) => {
+      result[key] = values[i];
+    });
+    return result;
+  }), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+  $.subscribe();
+  return {
+    $,
+    children,
+    get: () => {
+      const result = {};
+      for (const [key, child] of children) {
+        result[key] = child.get();
+      }
+      return result;
+    },
+    set: (v) => {
+      const arr = [...parentArray$.getValue()];
+      arr[index] = v;
+      parentArray$.next(arr);
+      for (const [key, child] of children) {
+        child.set(v[key]);
+      }
+    }
+  };
+}
+function createArrayElementPropertyNode(parentArray$, index, key, initialValue) {
+  if (initialValue !== null && typeof initialValue === "object") {
+    if (Array.isArray(initialValue)) {
+      return createNestedArrayProjection(parentArray$, index, key, initialValue);
+    }
+    return createNestedObjectProjection(parentArray$, index, key, initialValue);
+  }
+  const prop$ = parentArray$.pipe(map2((arr) => arr[index]?.[key]), countedDistinctUntilChanged(), shareReplay(1));
+  prop$.subscribe();
+  return {
+    $: prop$,
+    get: () => {
+      const arr = parentArray$.getValue();
+      return arr[index]?.[key];
+    },
+    set: (v) => {
+      const arr = [...parentArray$.getValue()];
+      arr[index] = { ...arr[index], [key]: v };
+      parentArray$.next(arr);
+    }
+  };
+}
+function createNestedObjectProjection(parentArray$, index, key, initialValue) {
+  const keys = Object.keys(initialValue);
+  const children = new Map;
+  for (const nestedKey of keys) {
+    const nested$ = parentArray$.pipe(map2((arr) => {
+      const element = arr[index];
+      const obj = element?.[key];
+      return obj?.[nestedKey];
+    }), countedDistinctUntilChanged(), shareReplay(1));
+    nested$.subscribe();
+    children.set(nestedKey, {
+      $: nested$,
+      get: () => {
+        const arr = parentArray$.getValue();
+        const element = arr[index];
+        const obj = element?.[key];
+        return obj?.[nestedKey];
+      },
+      set: (v) => {
+        const arr = [...parentArray$.getValue()];
+        const element = { ...arr[index] };
+        element[key] = { ...element[key], [nestedKey]: v };
+        arr[index] = element;
+        parentArray$.next(arr);
+      }
+    });
+  }
+  const obj$ = parentArray$.pipe(map2((arr) => arr[index]?.[key]), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+  obj$.subscribe();
+  return {
+    $: obj$,
+    children,
+    get: () => {
+      const arr = parentArray$.getValue();
+      return arr[index]?.[key];
+    },
+    set: (v) => {
+      const arr = [...parentArray$.getValue()];
+      arr[index] = { ...arr[index], [key]: v };
+      parentArray$.next(arr);
+    }
+  };
+}
+function createNestedArrayProjection(parentArray$, index, key, initialValue) {
+  const arr$ = parentArray$.pipe(map2((arr) => arr[index]?.[key]), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+  arr$.subscribe();
+  return {
+    $: arr$,
+    get: () => {
+      const arr = parentArray$.getValue();
+      return arr[index]?.[key];
+    },
+    set: (v) => {
+      const arr = [...parentArray$.getValue()];
+      arr[index] = { ...arr[index], [key]: v };
+      parentArray$.next(arr);
+    }
+  };
+}
+function createNodeForValue(value, maybeNullable = false) {
+  if (isNullableMarked(value)) {
+    delete value[NULLABLE_MARKER];
+    return createNullableObjectNode(value);
+  }
+  if (value === null || value === undefined) {
+    if (maybeNullable) {
+      return createNullableObjectNode(value);
+    }
+    return createLeafNode(value);
+  }
+  if (typeof value !== "object") {
+    return createLeafNode(value);
+  }
+  if (Array.isArray(value)) {
+    return createArrayNode(value);
+  }
+  return createObjectNode(value);
+}
+function wrapNullableWithProxy(node) {
+  const update = (callback) => {
+    node.lock();
+    try {
+      const childrenProxy = new Proxy({}, {
+        get(_, prop) {
+          if (typeof prop === "string") {
+            const child = node.getChild(prop);
+            if (child) {
+              return wrapWithProxy(child);
+            }
+          }
+          return;
+        }
+      });
+      callback(childrenProxy);
+    } finally {
+      node.unlock();
+    }
+    return node.get();
+  };
+  const proxy = new Proxy(node.$, {
+    get(target, prop) {
+      if (prop === "subscribe")
+        return node.$.subscribe.bind(node.$);
+      if (prop === "pipe")
+        return node.$.pipe.bind(node.$);
+      if (prop === "forEach")
+        return node.$.forEach?.bind(node.$);
+      if (prop === "get")
+        return node.get;
+      if (prop === "set")
+        return node.set;
+      if (prop === "update")
+        return update;
+      if (prop === "subscribeOnce")
+        return node.subscribeOnce;
+      if (prop === NODE)
+        return node;
+      if (prop === Symbol.observable || prop === "@@observable") {
+        return () => node.$;
+      }
+      if (typeof prop === "string") {
+        const child = node.getOrCreateChild(prop);
+        return wrapWithProxy(child);
+      }
+      if (prop in target) {
+        const val = target[prop];
+        return typeof val === "function" ? val.bind(target) : val;
+      }
+      return;
+    },
+    has(_, prop) {
+      if (!node.isNull() && node.children && typeof prop === "string") {
+        return node.children.has(prop);
+      }
+      return false;
+    },
+    ownKeys() {
+      if (!node.isNull() && node.children) {
+        return Array.from(node.children.keys());
+      }
+      return [];
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (!node.isNull() && node.children && typeof prop === "string" && node.children.has(prop)) {
+        return { enumerable: true, configurable: true };
+      }
+      return;
+    }
+  });
+  return proxy;
+}
+function wrapWithProxy(node) {
+  if (isNullableNode(node)) {
+    return wrapNullableWithProxy(node);
+  }
+  const value = node.get();
+  if (value === null || typeof value !== "object") {
+    return Object.assign(node.$, {
+      get: node.get,
+      set: node.set,
+      subscribe: node.$.subscribe.bind(node.$),
+      pipe: node.$.pipe.bind(node.$),
+      subscribeOnce: node.subscribeOnce,
+      [NODE]: node
+    });
+  }
+  if (Array.isArray(value)) {
+    const arrayNode = node;
+    const wrapped = Object.assign(node.$, {
+      get: node.get,
+      set: node.set,
+      subscribe: node.$.subscribe.bind(node.$),
+      pipe: node.$.pipe.bind(node.$),
+      subscribeOnce: node.subscribeOnce,
+      at: (index) => {
+        const child = arrayNode.at(index);
+        if (!child)
+          return;
+        return wrapWithProxy(child);
+      },
+      length: arrayNode.length$,
+      push: arrayNode.push,
+      pop: arrayNode.pop,
+      map: arrayNode.mapItems,
+      filter: arrayNode.filterItems,
+      update: (callback) => {
+        arrayNode.lock();
+        try {
+          callback(wrapped);
+        } finally {
+          arrayNode.unlock();
+        }
+        return node.get();
+      },
+      [NODE]: node
+    });
+    return wrapped;
+  }
+  const objectNode = node;
+  let updateFn;
+  const proxy = new Proxy(node.$, {
+    get(target, prop) {
+      if (prop === "subscribe")
+        return node.$.subscribe.bind(node.$);
+      if (prop === "pipe")
+        return node.$.pipe.bind(node.$);
+      if (prop === "forEach")
+        return node.$.forEach?.bind(node.$);
+      if (prop === "get")
+        return node.get;
+      if (prop === "set")
+        return node.set;
+      if (prop === "update")
+        return updateFn;
+      if (prop === "subscribeOnce")
+        return node.subscribeOnce;
+      if (prop === NODE)
+        return node;
+      if (prop === Symbol.observable || prop === "@@observable") {
+        return () => node.$;
+      }
+      if (objectNode.children && typeof prop === "string") {
+        const child = objectNode.children.get(prop);
+        if (child) {
+          return wrapWithProxy(child);
+        }
+      }
+      if (prop in target) {
+        const val = target[prop];
+        return typeof val === "function" ? val.bind(target) : val;
+      }
+      return;
+    },
+    has(target, prop) {
+      if (objectNode.children && typeof prop === "string") {
+        return objectNode.children.has(prop);
+      }
+      return prop in target;
+    },
+    ownKeys() {
+      if (objectNode.children) {
+        return Array.from(objectNode.children.keys());
+      }
+      return [];
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (objectNode.children && typeof prop === "string" && objectNode.children.has(prop)) {
+        return { enumerable: true, configurable: true };
+      }
+      return;
+    }
+  });
+  if (objectNode.lock && objectNode.unlock) {
+    updateFn = (callback) => {
+      objectNode.lock();
+      try {
+        callback(proxy);
+      } finally {
+        objectNode.unlock();
+      }
+      return node.get();
+    };
+  }
+  return proxy;
+}
+function state(initialState) {
+  const node = createObjectNode(initialState);
+  return wrapWithProxy(node);
+}
+var NULLABLE_MARKER = Symbol("nullable");
+function nullable(value) {
+  if (value === null) {
+    return null;
+  }
+  return Object.assign(value, { [NULLABLE_MARKER]: true });
+}
+function isNullableMarked(value) {
+  return value !== null && typeof value === "object" && NULLABLE_MARKER in value;
+}
+export {
+  state,
+  selectFromEach,
+  select,
+  nullable
+};