cross-state 0.6.0

package/README.md

@@ -0,0 +1,63 @@
+[![npm badge](https://badgen.net/npm/v/schummar-state)](https://www.npmjs.com/package/schummar-state)
+[![bundlephobia badge](https://badgen.net/bundlephobia/minzip/schummar-state)](https://bundlephobia.com/result?p=schummar-state)
+
+Lighweight React hooks based state library.
+Heavily inspired by [pullstate](https://github.com/lostpebble/pullstate)
+
+# Getting started
+
+### Install
+
+```
+npm install schummar-state
+```
+
+### Create a store
+
+```ts
+import { Store } from 'schummar-state';
+
+export const store = new Store({
+  counter: 0,
+});
+```
+
+You can easily use multiple stores in parallel.
+
+### Use store in a component
+
+```tsx
+import store from './store.ts';
+
+export function App() {
+  const counter = store.useState((state) => state.counter);
+
+  return (
+    <div>
+      <div>Counter: {counter}</div>
+    </div>
+  );
+}
+```
+
+### Update a store
+
+```tsx
+import store from './store.ts';
+
+export function App() {
+  const counter = store.useState((state) => state.counter);
+
+  const increment = () =>
+    store.update((state) => {
+      state.counter++;
+    });
+
+  return (
+    <div>
+      <div>Counter: {counter}</div>
+      <button onClick={increment}>Increment</button>
+    </div>
+  );
+}
+```

package/dist/cjs/hash.cjs

@@ -0,0 +1,632 @@
+"use strict";
+function queue() {
+  const q = [];
+  let promise, resolve;
+  let active = false;
+  const run = async () => {
+    if (!active) {
+      active = true;
+      let next;
+      while (next = q.shift()) {
+        try {
+          let result = next.action();
+          if (result instanceof Promise) {
+            result = await result;
+          }
+          next.resolve(result);
+        } catch (e) {
+          next.reject(e);
+        }
+      }
+      active = false;
+      resolve == null ? void 0 : resolve();
+    }
+  };
+  return Object.assign(
+    (action) => {
+      return new Promise((resolve2, reject) => {
+        q.push({ action, resolve: resolve2, reject });
+        run();
+      });
+    },
+    {
+      clear() {
+        q.length = 0;
+        resolve == null ? void 0 : resolve();
+      },
+      get whenDone() {
+        if (!promise) {
+          promise = new Promise((r) => {
+            resolve = () => {
+              promise = void 0;
+              resolve = void 0;
+              r();
+            };
+          });
+        }
+        return promise;
+      }
+    }
+  );
+}
+const ProxyKeys = ["get", "getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys"];
+const isPlainObject = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+function trackingProxy(value) {
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return [value, (other) => other === value];
+  }
+  const deps = new Array();
+  const proxy = new Proxy(
+    value,
+    Object.fromEntries(
+      ProxyKeys.map((key) => [
+        key,
+        (value2, ...args) => {
+          const fn = Reflect[key];
+          const [proxiedValue, equals] = trackingProxy(fn(value2, ...args));
+          deps.push((otherValue) => {
+            if (!isPlainObject(otherValue) && !Array.isArray(otherValue)) {
+              return false;
+            }
+            return equals(fn(otherValue, ...args));
+          });
+          return proxiedValue;
+        }
+      ])
+    )
+  );
+  return [proxy, (other) => !!other && deps.every((equals) => equals(other))];
+}
+class CalculationHelper {
+  constructor(options) {
+    this.options = options;
+    options.addEffect(() => {
+      if (this.current) {
+        this.current.check();
+      } else {
+        this.execute();
+      }
+    });
+  }
+  execute() {
+    this.stop();
+    const { calculate, addEffect, getValue, setValue, setError, onInvalidate } = this.options;
+    const checks = new Array();
+    const deps = /* @__PURE__ */ new Map();
+    const q = queue();
+    let isActive = false;
+    let isCancled = false;
+    const cancelEffect = addEffect(() => {
+      isActive = true;
+      for (const dep of deps.values()) {
+        dep.on();
+      }
+      return () => {
+        isActive = false;
+        for (const dep of deps.values()) {
+          dep.off();
+        }
+      };
+    });
+    const cancel = () => {
+      isCancled = true;
+      cancelSubscription == null ? void 0 : cancelSubscription();
+      cancelEffect();
+      delete this.current;
+    };
+    const check = () => {
+      if (!checks.every((check2) => check2())) {
+        cancel();
+        onInvalidate == null ? void 0 : onInvalidate();
+      }
+    };
+    const use = (store2, { disableProxy } = {}) => {
+      if (isCancled) {
+        return store2.get();
+      }
+      let value = store2.get();
+      let equals = (newValue) => {
+        return newValue === value;
+      };
+      if (!disableProxy) {
+        [value, equals] = trackingProxy(value);
+      }
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store2.sub(check, { runNow: false });
+        },
+        off() {
+          sub == null ? void 0 : sub();
+          sub = void 0;
+        }
+      };
+      if (isActive) {
+        dep.on();
+      }
+      checks.push(() => equals(store2.get()));
+      deps.set(store2, dep);
+      return value;
+    };
+    const useFetch = (store2) => {
+      if (isCancled) {
+        return store2.fetch();
+      }
+      const value = store2.fetch();
+      const ref = store2.get().ref;
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store2.sub(check, { runNow: false });
+        },
+        off() {
+          sub == null ? void 0 : sub();
+          sub = void 0;
+        }
+      };
+      if (isActive) {
+        dep.on();
+      }
+      checks.push(() => {
+        return store2.get().ref === ref;
+      });
+      deps.set(store2, dep);
+      return value;
+    };
+    const updateValue = (update) => q(async () => {
+      if (isCancled) {
+        return;
+      }
+      if (update instanceof Function) {
+        try {
+          update = update(getValue());
+        } catch (error) {
+          setError == null ? void 0 : setError(error);
+          return;
+        }
+      }
+      if (update instanceof Promise) {
+        try {
+          update = await update;
+        } catch (error) {
+          if (!isCancled) {
+            setError == null ? void 0 : setError(error);
+          }
+          return;
+        }
+      }
+      if (!isCancled) {
+        setValue == null ? void 0 : setValue(update);
+      }
+    });
+    const updateError = (error) => q(() => {
+      if (!isCancled) {
+        setError == null ? void 0 : setError(error);
+      }
+    });
+    let cancelSubscription;
+    try {
+      cancelSubscription = calculate({ use, useFetch, updateValue, updateError });
+    } catch (error) {
+      setError == null ? void 0 : setError(error);
+    }
+    this.current = { cancel, check };
+  }
+  stop() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.cancel();
+  }
+  check() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.check();
+  }
+}
+function get(obj, path) {
+  if (path === "") {
+    return obj;
+  }
+  if (!(obj instanceof Object)) {
+    throw new Error(`Could not get ${path} of ${obj}`);
+  }
+  const index = path.indexOf(".");
+  if (index >= 0) {
+    const key = path.slice(0, index);
+    const rest = path.slice(index + 1);
+    const subObj = obj[key];
+    if (!subObj) {
+      return void 0;
+    }
+    return get(subObj, rest);
+  }
+  return obj[path];
+}
+function set(obj, path, value, rootPath = path) {
+  if (path === "") {
+    return value;
+  }
+  if (!(obj instanceof Object)) {
+    throw new Error(`Could not set ${path} of ${obj}`);
+  }
+  const index = path.indexOf(".");
+  let key, update;
+  if (index >= 0) {
+    key = path.slice(0, index);
+    const rest = path.slice(index + 1);
+    const subObj = obj[key];
+    if (!subObj) {
+      const prefix = rootPath.slice(0, -rest.length - 1);
+      throw Error(`Cannot set ${rootPath} because ${prefix} is ${subObj}`);
+    }
+    update = set(subObj, rest, value, rootPath);
+  } else {
+    key = path;
+    update = value instanceof Function ? value(obj[key]) : value;
+  }
+  if (Array.isArray(obj)) {
+    const copy = Array.from(obj);
+    copy[key] = update;
+    return copy;
+  }
+  return {
+    ...obj,
+    [key]: update
+  };
+}
+function makeSelector(selector) {
+  if (!selector) {
+    return (x) => x;
+  }
+  if (selector instanceof Function) {
+    return selector;
+  }
+  return (x) => get(x, selector);
+}
+const getAllProperties = (object) => {
+  const properties = /* @__PURE__ */ new Set();
+  do {
+    for (const key of Reflect.ownKeys(object)) {
+      properties.add([object, key]);
+    }
+  } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+  return properties;
+};
+function bind(self) {
+  for (const [object, key] of getAllProperties(self.constructor.prototype)) {
+    if (key === "constructor") {
+      continue;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      self[key] = self[key].bind(self);
+    }
+  }
+}
+const calcDuration = (t) => {
+  if (typeof t === "number")
+    return t;
+  return (t.milliseconds ?? 0) + (t.seconds ?? 0) * 1e3 + (t.minutes ?? 0) * 60 * 1e3 + (t.hours ?? 0) * 60 * 60 * 1e3 + (t.days ?? 0) * 24 * 60 * 60 * 1e3;
+};
+const defaultEquals = (a, b) => a === b;
+const simpleShallowEquals = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((value, i) => value === b[i]);
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    if (a === null || b === null) {
+      return false;
+    }
+    const e1 = Object.entries(a);
+    const e2 = Object.entries(b);
+    return e1.length === e2.length && e1.every(([key, value]) => value === b[key]);
+  }
+  return false;
+};
+function forwardError(error) {
+  setTimeout(() => {
+    throw error;
+  });
+}
+const arrMod = (prop) => function(...args) {
+  const newArr = this.get().slice();
+  const result = newArr[prop](...args);
+  this.update(newArr);
+  return result;
+};
+const arrayActions = {
+  splice: arrMod("splice"),
+  push: arrMod("push"),
+  pop: arrMod("pop"),
+  shift: arrMod("shift"),
+  unshift: arrMod("unshift"),
+  reverse: arrMod("reverse"),
+  sort: arrMod("sort")
+};
+const recordActions = {
+  set(key, value) {
+    if (value instanceof Function) {
+      value = value(this.get()[key]);
+    }
+    this.update({ ...this.get(), [key]: value });
+    return this;
+  },
+  delete(key) {
+    const copy = { ...this.get() };
+    delete copy[key];
+    this.update(copy);
+  },
+  clear() {
+    this.update({});
+  }
+};
+const mapActions = {
+  set(key, value) {
+    const newMap = new Map(this.get());
+    newMap.set(key, value);
+    this.update(newMap);
+    return this;
+  },
+  delete(key) {
+    const newMap = new Map(this.get());
+    const result = newMap.delete(key);
+    this.update(newMap);
+    return result;
+  },
+  clear() {
+    this.update(/* @__PURE__ */ new Map());
+  }
+};
+const setActions = {
+  add(value) {
+    const newSet = new Set(this.get());
+    newSet.add(value);
+    this.update(newSet);
+  },
+  delete(value) {
+    const newSet = new Set(this.get());
+    newSet.delete(value);
+    this.update(newSet);
+  },
+  clear() {
+    this.update(/* @__PURE__ */ new Set());
+  }
+};
+function throttle(fn, ms) {
+  let t = 0;
+  let timeout;
+  return (...args) => {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    const dt = t + ms - Date.now();
+    if (dt <= 0) {
+      fn(...args);
+      t = Date.now();
+      return;
+    }
+    timeout = setTimeout(() => {
+      fn(...args);
+      t = Date.now();
+    }, dt);
+  };
+}
+const noop = () => void 0;
+class Store {
+  constructor(initialValue, options = {}) {
+    this.initialValue = initialValue;
+    this.options = options;
+    this.value = this.initialValue;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.effects = /* @__PURE__ */ new Map();
+    this.notifyId = {};
+    bind(this);
+  }
+  get() {
+    return this.value;
+  }
+  update(update) {
+    if (update instanceof Function) {
+      update = update(this.get());
+    }
+    this.value = update;
+    this.notify();
+  }
+  sub(listener, options) {
+    const { runNow = true, throttle: throttleOption, equals = defaultEquals } = options ?? {};
+    let compareToValue = this.get();
+    let previousValue;
+    let hasRun = false;
+    let innerListener = (force) => {
+      const value = this.get();
+      if (!force && equals(value, compareToValue)) {
+        return;
+      }
+      compareToValue = value;
+      const _previousValue = previousValue;
+      previousValue = value;
+      hasRun = true;
+      try {
+        listener(value, _previousValue);
+      } catch (error) {
+        forwardError(error);
+      }
+    };
+    if (throttleOption) {
+      innerListener = throttle(innerListener, calcDuration(throttleOption));
+    }
+    this.listeners.add(innerListener);
+    this.onSubscribe();
+    if (runNow && !hasRun) {
+      innerListener(true);
+    }
+    return () => {
+      this.listeners.delete(innerListener);
+      this.onUnsubscribe();
+    };
+  }
+  map(_selector, options) {
+    const selector = makeSelector(_selector);
+    const derivedFrom = { store: this, selectors: [_selector] };
+    return new DerivedStore(({ use }) => {
+      return selector(use(this, options));
+    }, derivedFrom);
+  }
+  addEffect(effect, retain) {
+    this.effects.set(effect, {
+      handle: this.listeners.size > 0 ? effect() ?? noop : void 0,
+      retain: retain !== void 0 ? calcDuration(retain) : void 0
+    });
+    return () => {
+      const { handle, timeout } = this.effects.get(effect) ?? {};
+      handle == null ? void 0 : handle();
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.delete(effect);
+    };
+  }
+  get isActive() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+    if (this.listeners.size > 1)
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.set(effect, {
+        handle: handle ?? effect() ?? noop,
+        retain,
+        timeout: void 0
+      });
+    }
+  }
+  onUnsubscribe() {
+    if (this.listeners.size > 0)
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      !retain && (handle == null ? void 0 : handle());
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.set(effect, {
+        handle: retain ? handle : void 0,
+        retain,
+        timeout: retain && handle ? setTimeout(handle, retain) : void 0
+      });
+    }
+  }
+  notify() {
+    const n = this.notifyId = {};
+    for (const listener of [...this.listeners]) {
+      listener();
+      if (n !== this.notifyId)
+        break;
+    }
+  }
+}
+const defaultOptions = {};
+function _store(initialState, options) {
+  if (initialState instanceof Function) {
+    return new DerivedStore(initialState);
+  }
+  let methods = options == null ? void 0 : options.methods;
+  if (initialState instanceof Map) {
+    methods = { ...mapActions, ...methods };
+  } else if (initialState instanceof Set) {
+    methods = { ...setActions, ...methods };
+  } else if (Array.isArray(initialState)) {
+    methods = { ...arrayActions, ...methods };
+  } else if (initialState instanceof Object) {
+    methods = { ...recordActions, ...methods };
+  }
+  const store2 = new Store(initialState, options);
+  const boundActions = Object.fromEntries(
+    Object.entries(methods ?? {}).filter(([name]) => !(name in store2)).map(([name, fn]) => [name, fn.bind(store2)])
+  );
+  return Object.assign(store2, boundActions);
+}
+const store = Object.assign(_store, { defaultOptions });
+class DerivedStore extends Store {
+  constructor(calculate, derivedFrom) {
+    super(void 0);
+    this.calculate = calculate;
+    this.derivedFrom = derivedFrom;
+    this.calculationHelper = new CalculationHelper({
+      calculate: ({ use }) => {
+        const value = this.calculate.apply({ use }, [{ use }]);
+        this.valid = true;
+        super.update(value);
+      },
+      addEffect: this.addEffect,
+      getValue: () => this.value,
+      onInvalidate: this.invalidate
+    });
+    this.valid = false;
+  }
+  get() {
+    if (!this.valid) {
+      this.calculationHelper.execute();
+    }
+    return super.get();
+  }
+  update(update) {
+    if (this.derivedFrom && this.derivedFrom.selectors.every((selector) => typeof selector === "string")) {
+      const path = this.derivedFrom.selectors.join(".");
+      if (update instanceof Function) {
+        const before = get(this.derivedFrom.store, path);
+        update = update(before);
+      }
+      this.derivedFrom.store.update((before) => set(before, path, update));
+    } else {
+      throw new Error("Can only updated computed stores that are derived from other stores using string selectors");
+    }
+  }
+  map(_selector) {
+    const selector = makeSelector(_selector);
+    const derivedFrom = this.derivedFrom ?? { store: this, selectors: [] };
+    const newDerivedFrom = { ...derivedFrom, selectors: derivedFrom.selectors.concat(_selector) };
+    return new DerivedStore(({ use }) => {
+      return selector(use(this));
+    }, newDerivedFrom);
+  }
+  invalidate() {
+    this.valid = false;
+    if (this.isActive) {
+      this.calculationHelper.execute();
+    }
+  }
+}
+function _derivedStore(calculate) {
+  return new DerivedStore(calculate);
+}
+const derivedStore = Object.assign(_derivedStore, {});
+function hash(value) {
+  if (value instanceof Set) {
+    return `s[${[...value].map(hash).sort().join(",")}]`;
+  }
+  if (value instanceof Map) {
+    return `m[${[...value.entries()].map(hash).sort().join(",")}]`;
+  }
+  if (value instanceof Array) {
+    return `[${value.map(hash).join(",")}]`;
+  }
+  if (value instanceof Object) {
+    return `o[${Object.entries(value).map(hash).sort().join(",")}]`;
+  }
+  return JSON.stringify(value);
+}
+exports.CalculationHelper = CalculationHelper;
+exports.Store = Store;
+exports.arrayActions = arrayActions;
+exports.calcDuration = calcDuration;
+exports.defaultEquals = defaultEquals;
+exports.derivedStore = derivedStore;
+exports.hash = hash;
+exports.makeSelector = makeSelector;
+exports.mapActions = mapActions;
+exports.recordActions = recordActions;
+exports.setActions = setActions;
+exports.simpleShallowEquals = simpleShallowEquals;
+exports.store = store;
+exports.trackingProxy = trackingProxy;
+//# sourceMappingURL=hash.cjs.map