valdres-solid 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,174 @@
+// src/createAtom.ts
+import { from } from "solid-js";
+import { isPromiseLike } from "valdres";
+
+// src/useStore.ts
+import { useContext } from "solid-js";
+
+// src/lib/storeContext.ts
+import { createContext } from "solid-js";
+var StoreContext = createContext();
+
+// src/useStore.ts
+var useStore = (id) => {
+  const ctx = useContext(StoreContext);
+  if (!ctx) {
+    throw new Error("No valdres store found. Wrap your component tree with <ValdresProvider>.");
+  }
+  if (id) {
+    const store = ctx.stores[id];
+    if (!store) {
+      throw new Error(`No store with id "${id}" found in ancestor chain`);
+    }
+    return store;
+  }
+  return ctx.current;
+};
+
+// src/createAtom.ts
+var createAtom = (atom, store) => {
+  const currentStore = store || useStore();
+  const initial = currentStore.get(atom);
+  if (isPromiseLike(initial)) {
+    throw initial;
+  }
+  const value = from((set) => {
+    set(() => initial);
+    return currentStore.sub(atom, () => {
+      const next = currentStore.get(atom);
+      if (!isPromiseLike(next)) {
+        set(() => next);
+      }
+    }, false);
+  });
+  const setter = (val) => currentStore.set(atom, val);
+  return [value, setter];
+};
+// src/createResetAtom.ts
+var createResetAtom = (atom, store) => {
+  const currentStore = store || useStore();
+  return () => currentStore.reset(atom);
+};
+// src/createSetAtom.ts
+var createSetAtom = (atom, store) => {
+  const currentStore = store || useStore();
+  return (value) => currentStore.set(atom, value);
+};
+// src/createTransaction.ts
+var createTransaction = (store) => {
+  const currentStore = store || useStore();
+  return (callback) => currentStore.txn(callback);
+};
+// src/createValue.ts
+import { from as from2 } from "solid-js";
+import { isPromiseLike as isPromiseLike2 } from "valdres";
+var createValue = (state, store) => {
+  const currentStore = store || useStore();
+  const initial = currentStore.get(state);
+  if (isPromiseLike2(initial)) {
+    throw initial;
+  }
+  return from2((set) => {
+    set(() => initial);
+    return currentStore.sub(state, () => {
+      const next = currentStore.get(state);
+      if (!isPromiseLike2(next)) {
+        set(() => next);
+      }
+    }, false);
+  });
+};
+// src/ValdresProvider.ts
+import { useContext as useContext2 } from "solid-js";
+import { store as createStore } from "valdres";
+
+// src/lib/hydrate.ts
+var hydrate = (set, state) => {
+  for (const [atom, value] of state) {
+    set(atom, value);
+  }
+};
+
+// src/ValdresProvider.ts
+var ValdresProvider = (props) => {
+  const parentCtx = useContext2(StoreContext);
+  let store = props.store;
+  if (store) {
+    if (!store.data.batchUpdates) {
+      console.warn("valdres-solid: The store passed to ValdresProvider was not created " + "with { batchUpdates: true }. Sequential store.set() calls " + "will trigger intermediate selector evaluations. Consider " + "using store({ batchUpdates: true }) for optimal performance.");
+    }
+  } else {
+    store = createStore({ batchUpdates: true });
+  }
+  if (parentCtx) {
+    if (store.data.id in parentCtx.stores) {
+      throw new Error(`store with id ${store.data.id} is already defined further up the tree`);
+    }
+  }
+  if (props.initialize) {
+    store.txn((txn) => {
+      const pairs = props.initialize(txn);
+      if (pairs) {
+        hydrate(txn.set, pairs);
+      }
+    });
+  }
+  return StoreContext.Provider({
+    value: {
+      current: store,
+      stores: {
+        ...parentCtx?.stores ?? {},
+        [store.data.id]: store
+      }
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+// src/ValdresScope.ts
+import { useContext as useContext3, onCleanup, createUniqueId } from "solid-js";
+var ValdresScope = (props) => {
+  const parentCtx = useContext3(StoreContext);
+  if (!parentCtx) {
+    throw new Error("No valdres store found. ValdresScope must be nested under a <ValdresProvider> or another <ValdresScope>.");
+  }
+  const scopeId = props.scopeId || createUniqueId();
+  const scopeCreated = !parentCtx.current.data.scopes?.has(scopeId);
+  const scopedStore = parentCtx.current.scope(scopeId);
+  if (props.initialize) {
+    scopedStore.txn((txn) => {
+      const pairs = props.initialize(txn);
+      if (pairs) {
+        hydrate(txn.set, pairs);
+      }
+    });
+  }
+  onCleanup(() => {
+    scopedStore?.detach?.(scopeCreated);
+  });
+  return StoreContext.Provider({
+    value: {
+      current: scopedStore,
+      stores: {
+        ...parentCtx.stores,
+        [parentCtx.current.data.id]: parentCtx.current,
+        [scopedStore.data.id]: scopedStore
+      }
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+export {
+  useStore,
+  createValue,
+  createTransaction,
+  createSetAtom,
+  createResetAtom,
+  createAtom,
+  ValdresScope,
+  ValdresProvider,
+  StoreContext
+};

package/dist/types/ValdresProvider.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "solid-js";
+import { type Store } from "valdres";
+import type { InitializeCallback } from "./types/InitializeCallback";
+export interface ValdresProviderProps {
+    store?: Store;
+    initialize?: InitializeCallback;
+    children: JSX.Element;
+}
+export declare const ValdresProvider: (props: ValdresProviderProps) => JSX.Element;

package/dist/types/ValdresScope.d.ts

@@ -0,0 +1,8 @@
+import { type JSX } from "solid-js";
+import type { InitializeCallback } from "./types/InitializeCallback";
+export interface ValdresScopeProps {
+    scopeId?: string;
+    initialize?: InitializeCallback;
+    children: JSX.Element;
+}
+export declare const ValdresScope: (props: ValdresScopeProps) => JSX.Element;

package/dist/types/createAtom.d.ts

@@ -0,0 +1,5 @@
+import { type Accessor } from "solid-js";
+import { type Atom, type SetAtomValue, type Store } from "valdres";
+type SetterFn<V> = (value: SetAtomValue<V>) => void;
+export declare const createAtom: <V>(atom: Atom<V>, store?: Store) => [Accessor<V>, SetterFn<V>];
+export {};

package/dist/types/createResetAtom.d.ts

@@ -0,0 +1,2 @@
+import type { Atom, Store } from "valdres";
+export declare const createResetAtom: <V>(atom: Atom<V>, store?: Store) => (() => void);

package/dist/types/createSetAtom.d.ts

@@ -0,0 +1,2 @@
+import type { Atom, SetAtomValue, Store } from "valdres";
+export declare const createSetAtom: <V>(atom: Atom<V>, store?: Store) => (value: SetAtomValue<V>) => void;

package/dist/types/createTransaction.d.ts

@@ -0,0 +1,2 @@
+import type { Store, Transaction } from "valdres";
+export declare const createTransaction: (store?: Store) => (callback: (txn: Transaction) => any) => void;

package/dist/types/createValue.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from "solid-js";
+import { type State, type Store } from "valdres";
+export declare const createValue: <Value extends any = any, Args extends [any, ...any[]] = [any, ...any[]]>(state: State<Value, Args>, store?: Store) => Accessor<Value>;

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { createAtom } from "./createAtom";
+export { createResetAtom } from "./createResetAtom";
+export { createSetAtom } from "./createSetAtom";
+export { useStore } from "./useStore";
+export { createTransaction } from "./createTransaction";
+export { createValue } from "./createValue";
+export { ValdresProvider } from "./ValdresProvider";
+export type { ValdresProviderProps } from "./ValdresProvider";
+export { ValdresScope } from "./ValdresScope";
+export type { ValdresScopeProps } from "./ValdresScope";
+export { StoreContext } from "./lib/storeContext";
+export type { ValdresContext } from "./lib/storeContext";

package/dist/types/lib/hydrate.d.ts

@@ -0,0 +1,2 @@
+import type { Atom, SyncSetAtom } from "valdres";
+export declare const hydrate: (set: SyncSetAtom, state: [Atom, any][]) => void;

package/dist/types/lib/storeContext.d.ts

@@ -0,0 +1,6 @@
+import type { Store } from "valdres";
+export interface ValdresContext {
+    current: Store;
+    stores: Record<string, Store>;
+}
+export declare const StoreContext: import("solid-js").Context<ValdresContext | undefined>;

package/dist/types/types/InitializeCallback.d.ts

@@ -0,0 +1,4 @@
+import type { Atom, Transaction } from "valdres";
+type AtomPair = [Atom<any>, any];
+export type InitializeCallback = (txn: Transaction) => void | AtomPair[];
+export {};

package/dist/types/useStore.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "valdres";
+export declare const useStore: (id?: string) => Store;

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "valdres-solid",
+    "version": "0.1.0-beta.0",
+    "license": "MIT",
+    "author": {
+        "name": "Eigil Sagafos"
+    },
+    "homepage": "https://valdres.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/eigilsagafos/valdres.git"
+    },
+    "type": "module",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/types/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "peerDependencies": {
+        "valdres": "workspace:^",
+        "solid-js": ">=1.8"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
+}