ccstate 2.0.0 → 2.2.0

package/vue/index.d.cts

@@ -0,0 +1,53 @@
+import { ShallowRef } from 'vue';
+
+type Updater<T> = (current: T) => T;
+interface Setter {
+    <T>(state: State<T>, val: T | Updater<T>): void;
+    <T, Args extends unknown[]>(command: Command<T, Args>, ...args: Args): T;
+}
+type Getter = <T>(readable: ReadableAtom<T>) => T;
+interface GetterOptions {
+    signal: AbortSignal;
+}
+type Read<T> = (get: Getter, options: GetterOptions) => T;
+type Write<T, Args extends unknown[]> = (visitor: {
+    get: Getter;
+    set: Setter;
+}, ...args: Args) => T;
+interface State<T> {
+    init: T;
+    debugLabel?: string;
+    toString: () => string;
+}
+interface Computed<T> {
+    read: Read<T>;
+    debugLabel?: string;
+    toString: () => string;
+}
+interface Command<T, Args extends unknown[]> {
+    write: Write<T, Args>;
+    debugLabel?: string;
+    toString: () => string;
+}
+type ReadableAtom<T> = State<T> | Computed<T>;
+
+interface Store {
+    get: Getter;
+    set: Setter;
+    sub: Subscribe;
+}
+interface SubscribeOptions {
+    signal?: AbortSignal;
+}
+type CallbackFunc<T> = Command<T, []>;
+type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
+
+declare const provideStore: (store: Store) => void;
+declare const useStore: () => Store;
+
+declare function useGet<Value>(atom: Computed<Value> | State<Value>): Readonly<ShallowRef<Value>>;
+
+declare function useSet<T>(atom: State<T>): (value: T | Updater<T>) => void;
+declare function useSet<T, ARGS extends unknown[]>(atom: Command<T, ARGS>): (...args: ARGS) => T;
+
+export { provideStore, useGet, useSet, useStore };

package/vue/index.d.ts

@@ -0,0 +1,53 @@
+import { ShallowRef } from 'vue';
+
+type Updater<T> = (current: T) => T;
+interface Setter {
+    <T>(state: State<T>, val: T | Updater<T>): void;
+    <T, Args extends unknown[]>(command: Command<T, Args>, ...args: Args): T;
+}
+type Getter = <T>(readable: ReadableAtom<T>) => T;
+interface GetterOptions {
+    signal: AbortSignal;
+}
+type Read<T> = (get: Getter, options: GetterOptions) => T;
+type Write<T, Args extends unknown[]> = (visitor: {
+    get: Getter;
+    set: Setter;
+}, ...args: Args) => T;
+interface State<T> {
+    init: T;
+    debugLabel?: string;
+    toString: () => string;
+}
+interface Computed<T> {
+    read: Read<T>;
+    debugLabel?: string;
+    toString: () => string;
+}
+interface Command<T, Args extends unknown[]> {
+    write: Write<T, Args>;
+    debugLabel?: string;
+    toString: () => string;
+}
+type ReadableAtom<T> = State<T> | Computed<T>;
+
+interface Store {
+    get: Getter;
+    set: Setter;
+    sub: Subscribe;
+}
+interface SubscribeOptions {
+    signal?: AbortSignal;
+}
+type CallbackFunc<T> = Command<T, []>;
+type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
+
+declare const provideStore: (store: Store) => void;
+declare const useStore: () => Store;
+
+declare function useGet<Value>(atom: Computed<Value> | State<Value>): Readonly<ShallowRef<Value>>;
+
+declare function useSet<T>(atom: State<T>): (value: T | Updater<T>) => void;
+declare function useSet<T, ARGS extends unknown[]>(atom: Command<T, ARGS>): (...args: ARGS) => T;
+
+export { provideStore, useGet, useSet, useStore };

package/vue/index.js

@@ -0,0 +1,66 @@
+import { provide, inject, shallowRef, getCurrentInstance, onScopeDispose, shallowReadonly } from 'vue';
+
+var StoreKey = Symbol('ccstate-vue-store');
+var provideStore = function provideStore(store) {
+  provide(StoreKey, store);
+};
+var useStore = function useStore() {
+  var store = inject(StoreKey);
+  if (store === undefined) {
+    throw new Error('Store context not found - did you forget to wrap your app with StoreProvider?');
+  }
+  return store;
+};
+
+var globalId = 0;
+var generateToString = function generateToString(prefix, debugLabel) {
+  var id = globalId++;
+  var label = "".concat(prefix).concat(String(id)).concat('');
+  return function () {
+    return label;
+  };
+};
+function command(write, options) {
+  var ret = {
+    write: write,
+    toString: generateToString('F')
+  };
+  return ret;
+}
+
+function useGet(atom) {
+  var store = useStore();
+  var initialValue = store.get(atom);
+  var vueState = shallowRef(initialValue);
+  var controller = new AbortController();
+  store.sub(atom, command(function () {
+    var nextValue = store.get(atom);
+    vueState.value = nextValue;
+  }), {
+    signal: controller.signal
+  });
+  if (getCurrentInstance()) {
+    onScopeDispose(function () {
+      controller.abort();
+    });
+  }
+  return shallowReadonly(vueState);
+}
+
+function useSet(atom) {
+  var store = useStore();
+  if ('write' in atom) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var ret = store.set.apply(store, [atom].concat(args));
+      return ret;
+    };
+  }
+  return function (value) {
+    store.set(atom, value);
+  };
+}
+
+export { provideStore, useGet, useSet, useStore };