valdres-angular 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,231 @@
+// src/injectAtom.ts
+import { signal, DestroyRef, inject as inject2 } from "@angular/core";
+import { isPromiseLike } from "valdres";
+
+// src/injectStore.ts
+import { inject } from "@angular/core";
+
+// src/lib/VALDRES_STORE.ts
+import { InjectionToken } from "@angular/core";
+var VALDRES_STORE = new InjectionToken("VALDRES_STORE");
+
+// src/injectStore.ts
+var injectStore = (id) => {
+  const ctx = inject(VALDRES_STORE, { optional: true });
+  if (!ctx) {
+    throw new Error("No valdres store provided. Call provideValdres() in your application providers.");
+  }
+  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/injectAtom.ts
+var injectAtom = (atom, store) => {
+  const currentStore = store || injectStore();
+  const destroyRef = inject2(DestroyRef);
+  const initial = currentStore.get(atom);
+  if (isPromiseLike(initial)) {
+    throw new Error("injectAtom() received async state. Atoms should have synchronous default values.");
+  }
+  const inner = signal(initial);
+  const signalSet = inner.set.bind(inner);
+  const unsub = currentStore.sub(atom, () => {
+    const newValue = currentStore.get(atom);
+    if (!isPromiseLike(newValue)) {
+      signalSet(newValue);
+    }
+  }, false);
+  destroyRef.onDestroy(() => {
+    unsub();
+  });
+  const atomSignal = inner;
+  atomSignal.set = (value) => {
+    signalSet(value);
+    currentStore.set(atom, value);
+  };
+  atomSignal.update = (fn) => {
+    const next = fn(inner());
+    signalSet(next);
+    currentStore.set(atom, next);
+  };
+  atomSignal.reset = () => {
+    currentStore.reset(atom);
+    const resetValue = currentStore.get(atom);
+    if (!isPromiseLike(resetValue)) {
+      signalSet(resetValue);
+    }
+  };
+  return atomSignal;
+};
+// src/injectResetAtom.ts
+var injectResetAtom = (atom, store) => {
+  const selectedStore = store || injectStore();
+  return () => selectedStore.reset(atom);
+};
+// src/injectSetAtom.ts
+var injectSetAtom = (atom, store) => {
+  const selectedStore = store || injectStore();
+  return (value) => selectedStore.set(atom, value);
+};
+// src/injectTransaction.ts
+var injectTransaction = (store) => {
+  const selectedStore = store || injectStore();
+  return (callback) => selectedStore.txn(callback);
+};
+// src/injectValue.ts
+import {
+  signal as signal2,
+  computed,
+  DestroyRef as DestroyRef2,
+  inject as inject3
+} from "@angular/core";
+import { isPromiseLike as isPromiseLike2 } from "valdres";
+var injectValue = (state, store) => {
+  const currentStore = store || injectStore();
+  const destroyRef = inject3(DestroyRef2);
+  const value = signal2(undefined);
+  const status = signal2("loading");
+  const error = signal2(undefined);
+  let destroyed = false;
+  let hasResolved = false;
+  let currentVersion = 0;
+  const handleValue = (val) => {
+    if (isPromiseLike2(val)) {
+      const version = ++currentVersion;
+      status.set(hasResolved ? "reloading" : "loading");
+      val.then((resolved) => {
+        if (destroyed || version !== currentVersion)
+          return;
+        hasResolved = true;
+        value.set(resolved);
+        status.set("resolved");
+        error.set(undefined);
+      }, (err) => {
+        if (destroyed || version !== currentVersion)
+          return;
+        error.set(err);
+        status.set("error");
+      });
+    } else {
+      hasResolved = true;
+      value.set(val);
+      status.set("resolved");
+      error.set(undefined);
+    }
+  };
+  handleValue(currentStore.get(state));
+  const unsub = currentStore.sub(state, () => {
+    handleValue(currentStore.get(state));
+  }, false);
+  destroyRef.onDestroy(() => {
+    destroyed = true;
+    unsub();
+  });
+  return {
+    value: value.asReadonly(),
+    status: status.asReadonly(),
+    error: error.asReadonly(),
+    isLoading: computed(() => status() === "loading" || status() === "reloading"),
+    hasValue: computed(() => status() === "resolved" || status() === "reloading")
+  };
+};
+// src/provideValdres.ts
+import { makeEnvironmentProviders } from "@angular/core";
+import { store as createStore } from "valdres";
+
+// src/lib/hydrate.ts
+var hydrate = (set, state) => {
+  for (const [atom, value] of state) {
+    set(atom, value);
+  }
+};
+
+// src/provideValdres.ts
+var provideValdres = (options = {}) => {
+  return makeEnvironmentProviders([
+    {
+      provide: VALDRES_STORE,
+      useFactory: () => {
+        let store = options.store;
+        if (store) {
+          if (!store.data.batchUpdates) {
+            console.warn("valdres-angular: The store passed to provideValdres() 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 (options.initialize) {
+          store.txn((txn) => {
+            const pairs = options.initialize(txn);
+            if (pairs) {
+              hydrate(txn.set, pairs);
+            }
+          });
+        }
+        return {
+          current: store,
+          stores: { [store.data.id]: store }
+        };
+      }
+    }
+  ]);
+};
+// src/provideValdresScope.ts
+import { inject as inject4, DestroyRef as DestroyRef3 } from "@angular/core";
+var nextScopeId = 0;
+var generateId = () => globalThis.crypto?.randomUUID?.() ?? `valdres-scope-${++nextScopeId}`;
+var provideValdresScope = (options = {}) => {
+  return [
+    {
+      provide: VALDRES_STORE,
+      useFactory: () => {
+        const parentCtx = inject4(VALDRES_STORE, {
+          skipSelf: true,
+          optional: true
+        });
+        if (!parentCtx) {
+          throw new Error("No valdres store provided. provideValdresScope() must be nested under provideValdres().");
+        }
+        const destroyRef = inject4(DestroyRef3);
+        const scopeId = options.scopeId ?? generateId();
+        const scopeCreated = !parentCtx.current.data.scopes?.has(scopeId);
+        const scopedStore = parentCtx.current.scope(scopeId);
+        if (options.initialize) {
+          scopedStore.txn((txn) => {
+            const pairs = options.initialize(txn);
+            if (pairs) {
+              hydrate(txn.set, pairs);
+            }
+          });
+        }
+        destroyRef.onDestroy(() => {
+          scopedStore?.detach?.(scopeCreated);
+        });
+        return {
+          current: scopedStore,
+          stores: {
+            ...parentCtx.stores,
+            [parentCtx.current.data.id]: parentCtx.current,
+            [scopedStore.data.id]: scopedStore
+          }
+        };
+      }
+    }
+  ];
+};
+export {
+  provideValdresScope,
+  provideValdres,
+  injectValue,
+  injectTransaction,
+  injectStore,
+  injectSetAtom,
+  injectResetAtom,
+  injectAtom,
+  VALDRES_STORE
+};

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export { injectAtom } from "./injectAtom";
+export type { AtomSignal } from "./injectAtom";
+export { injectResetAtom } from "./injectResetAtom";
+export { injectSetAtom } from "./injectSetAtom";
+export { injectStore } from "./injectStore";
+export { injectTransaction } from "./injectTransaction";
+export { injectValue } from "./injectValue";
+export type { ValueState, ValueStatus } from "./injectValue";
+export { provideValdres } from "./provideValdres";
+export type { ValdresOptions } from "./provideValdres";
+export { provideValdresScope } from "./provideValdresScope";
+export type { ValdresScopeOptions } from "./provideValdresScope";
+export { VALDRES_STORE } from "./lib/VALDRES_STORE";
+export type { ValdresContext } from "./lib/VALDRES_STORE";

package/dist/types/injectAtom.d.ts

@@ -0,0 +1,6 @@
+import { type WritableSignal } from "@angular/core";
+import { type Atom, type Store } from "valdres";
+export type AtomSignal<V> = WritableSignal<V> & {
+    reset: () => void;
+};
+export declare const injectAtom: <V>(atom: Atom<V>, store?: Store) => AtomSignal<V>;

package/dist/types/injectResetAtom.d.ts

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

package/dist/types/injectSetAtom.d.ts

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

package/dist/types/injectStore.d.ts

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

package/dist/types/injectTransaction.d.ts

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

package/dist/types/injectValue.d.ts

@@ -0,0 +1,13 @@
+import { type Signal } from "@angular/core";
+import { type Atom, type Selector, type Store } from "valdres";
+/** Mirrors Angular's ResourceStatus naming where applicable. */
+export type ValueStatus = "loading" | "reloading" | "resolved" | "error";
+export interface ValueState<V> {
+    readonly value: Signal<V | undefined>;
+    readonly status: Signal<ValueStatus>;
+    readonly error: Signal<unknown | undefined>;
+    /** True when status is "loading" or "reloading". */
+    readonly isLoading: Signal<boolean>;
+    readonly hasValue: Signal<boolean>;
+}
+export declare const injectValue: <V>(state: Atom<V> | Selector<V>, store?: Store) => ValueState<V>;

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

@@ -0,0 +1,7 @@
+import { InjectionToken } from "@angular/core";
+import type { Store } from "valdres";
+export interface ValdresContext {
+    current: Store;
+    stores: Record<string, Store>;
+}
+export declare const VALDRES_STORE: InjectionToken<ValdresContext>;

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/provideValdres.d.ts

@@ -0,0 +1,7 @@
+import { type Store } from "valdres";
+import type { InitializeCallback } from "./types/InitializeCallback";
+export interface ValdresOptions {
+    store?: Store;
+    initialize?: InitializeCallback;
+}
+export declare const provideValdres: (options?: ValdresOptions) => import("@angular/core").EnvironmentProviders;

package/dist/types/provideValdresScope.d.ts

@@ -0,0 +1,7 @@
+import { type Provider } from "@angular/core";
+import type { InitializeCallback } from "./types/InitializeCallback";
+export interface ValdresScopeOptions {
+    scopeId?: string;
+    initialize?: InitializeCallback;
+}
+export declare const provideValdresScope: (options?: ValdresScopeOptions) => Provider[];

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/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "valdres-angular",
+    "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": {
+        "@angular/core": ">=17",
+        "valdres": "workspace:^"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
+}