@ng-primitives/state 0.29.0

package/README.md

@@ -0,0 +1,19 @@
+# Angular Primitives State
+
+Angular Primitives State is a low-level state library with a focus on developer experience.
+
+## Installation
+
+```bash
+npm install @ng-primitives/state
+```
+
+This package is auto-generated from `ng-primitives/state` and the source should be modified there.
+
+## Contributing
+
+We welcome contributions from the community. Please refer to our [contributing guidelines](CONTRIBUTING.md) for more information.
+
+## License
+
+Angular Primitives is licensed under the [Apache License 2.0](LICENSE).

package/fesm2022/ng-primitives-state.mjs

@@ -0,0 +1,61 @@
+import { InjectionToken, inject, signal, computed, isSignal, linkedSignal } from '@angular/core';
+
+/**
+ * Create a new injection token for the state.
+ * @param description The description of the token
+ */
+function createStateToken(description) {
+    return new InjectionToken(`Ngp${description}StateToken`);
+}
+/**
+ * Create a new provider for the state. It first tries to inject the state from the parent injector,
+ * as this allows for the state to be hoisted to a higher level in the component tree. This can
+ * be useful to avoid issues where the injector can't be shared in some cases when ng-content is used.
+ * @param token The token for the state
+ */
+function createStateProvider(token) {
+    return () => ({
+        provide: token,
+        useFactory: () => inject(token, { optional: true, skipSelf: true }) ?? signal({}),
+    });
+}
+function createStateInjector(token, options = {}) {
+    return () => {
+        const value = inject(token);
+        if (options.deferred) {
+            return computed(() => Object.keys(value() ?? {}).length === 0 ? undefined : value());
+        }
+        return value;
+    };
+}
+/**
+ * Convert the original state object into a writable state object.
+ * @param token The token for the state
+ */
+function createState(token) {
+    return (state) => {
+        const internalState = inject(token);
+        internalState.update(obj => {
+            // Iterating over properties
+            for (const key in state) {
+                const value = state[key];
+                // @ts-ignore
+                obj[key] = isSignal(value) ? linkedSignal(() => value()) : value;
+            }
+            // Iterating over prototype methods
+            const prototype = Object.getPrototypeOf(state);
+            for (const key of Object.getOwnPropertyNames(prototype)) {
+                obj[key] = prototype[key].bind(state);
+            }
+            return { ...obj };
+        });
+        return internalState();
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { createState, createStateInjector, createStateProvider, createStateToken };
+//# sourceMappingURL=ng-primitives-state.mjs.map

package/fesm2022/ng-primitives-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ng-primitives-state.mjs","sources":["../../../../packages/state/src/index.ts","../../../../packages/state/src/ng-primitives-state.ts"],"sourcesContent":["import {\n  computed,\n  FactoryProvider,\n  inject,\n  InjectionToken,\n  InputSignal,\n  InputSignalWithTransform,\n  isSignal,\n  linkedSignal,\n  ProviderToken,\n  signal,\n  Signal,\n  WritableSignal,\n} from '@angular/core';\n\n/**\n * This converts the state object to a writable state object.\n * This means that inputs become signals which are writable.\n */\nexport type State<T> = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [K in keyof T]: T[K] extends InputSignalWithTransform<infer U, any>\n    ? WritableSignal<U>\n    : T[K] extends InputSignal<infer R>\n      ? WritableSignal<R>\n      : T[K];\n};\n\nexport type InjectedState<T> = Signal<State<T>>;\n\n/**\n * Create a new injection token for the state.\n * @param description The description of the token\n */\nexport function createStateToken<T>(description: string): InjectionToken<T> {\n  return new InjectionToken<Signal<State<T>>>(`Ngp${description}StateToken`);\n}\n\n/**\n * Create a new provider for the state. It first tries to inject the state from the parent injector,\n * as this allows for the state to be hoisted to a higher level in the component tree. This can\n * be useful to avoid issues where the injector can't be shared in some cases when ng-content is used.\n * @param token The token for the state\n */\nexport function createStateProvider<T>(token: ProviderToken<T>): () => FactoryProvider {\n  return () => ({\n    provide: token,\n    useFactory: () => inject(token, { optional: true, skipSelf: true }) ?? signal({}),\n  });\n}\n\ntype CreateStateInjectorOptions = {\n  /**\n   * Whether the state may not be immediately available. This can happen when the child is instantiated before the parent.\n   */\n  deferred?: boolean;\n};\n\n/**\n * Create a new state injector for the state.\n * @param token The token for the state\n */\nexport function createStateInjector<T>(\n  token: ProviderToken<State<T>>,\n  options: { deferred: true },\n): <U = T>() => Signal<State<U> | undefined>;\nexport function createStateInjector<T>(\n  token: ProviderToken<State<T>>,\n  options?: CreateStateInjectorOptions,\n): <U = T>() => Signal<State<U>>;\nexport function createStateInjector<T>(\n  token: ProviderToken<State<T>>,\n  options: CreateStateInjectorOptions = {},\n): <U = T>() => Signal<State<U> | undefined> {\n  return <U = T>() => {\n    const value = inject(token) as Signal<State<U> | undefined>;\n\n    if (options.deferred) {\n      return computed(() =>\n        Object.keys(value() ?? {}).length === 0 ? undefined : value(),\n      ) as Signal<State<U> | undefined>;\n    }\n\n    return value as Signal<State<U>>;\n  };\n}\n\n/**\n * Convert the original state object into a writable state object.\n * @param token The token for the state\n */\nexport function createState(token: ProviderToken<WritableSignal<State<unknown>>>) {\n  return <U>(state: U): State<U> => {\n    const internalState = inject(token);\n\n    internalState.update(obj => {\n      // Iterating over properties\n      for (const key in state) {\n        const value = state[key as keyof U];\n\n        // @ts-ignore\n        obj[key] = isSignal(value) ? linkedSignal(() => value()) : value;\n      }\n\n      // Iterating over prototype methods\n      const prototype = Object.getPrototypeOf(state);\n\n      for (const key of Object.getOwnPropertyNames(prototype)) {\n        (obj as Record<string, unknown>)[key] = prototype[key as keyof U].bind(state);\n      }\n\n      return { ...obj };\n    });\n\n    return internalState() as unknown as State<U>;\n  };\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AA8BA;;;AAGG;AACG,SAAU,gBAAgB,CAAI,WAAmB,EAAA;AACrD,IAAA,OAAO,IAAI,cAAc,CAAmB,MAAM,WAAW,CAAA,UAAA,CAAY,CAAC;AAC5E;AAEA;;;;;AAKG;AACG,SAAU,mBAAmB,CAAI,KAAuB,EAAA;IAC5D,OAAO,OAAO;AACZ,QAAA,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,MAAM,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,MAAM,CAAC,EAAE,CAAC;AAClF,KAAA,CAAC;AACJ;SAqBgB,mBAAmB,CACjC,KAA8B,EAC9B,UAAsC,EAAE,EAAA;AAExC,IAAA,OAAO,MAAY;AACjB,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAiC;AAE3D,QAAA,IAAI,OAAO,CAAC,QAAQ,EAAE;AACpB,YAAA,OAAO,QAAQ,CAAC,MACd,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC,GAAG,SAAS,GAAG,KAAK,EAAE,CAC9B;;AAGnC,QAAA,OAAO,KAAyB;AAClC,KAAC;AACH;AAEA;;;AAGG;AACG,SAAU,WAAW,CAAC,KAAoD,EAAA;IAC9E,OAAO,CAAI,KAAQ,KAAc;AAC/B,QAAA,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC;AAEnC,QAAA,aAAa,CAAC,MAAM,CAAC,GAAG,IAAG;;AAEzB,YAAA,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE;AACvB,gBAAA,MAAM,KAAK,GAAG,KAAK,CAAC,GAAc,CAAC;;gBAGnC,GAAG,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,MAAM,KAAK,EAAE,CAAC,GAAG,KAAK;;;YAIlE,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC;YAE9C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAAE;AACtD,gBAAA,GAA+B,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAc,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;;AAG/E,YAAA,OAAO,EAAE,GAAG,GAAG,EAAE;AACnB,SAAC,CAAC;QAEF,OAAO,aAAa,EAAyB;AAC/C,KAAC;AACH;;ACpHA;;AAEG;;;;"}

package/index.d.ts

@@ -0,0 +1,41 @@
+import { FactoryProvider, InjectionToken, InputSignal, InputSignalWithTransform, ProviderToken, Signal, WritableSignal } from '@angular/core';
+/**
+ * This converts the state object to a writable state object.
+ * This means that inputs become signals which are writable.
+ */
+export type State<T> = {
+    [K in keyof T]: T[K] extends InputSignalWithTransform<infer U, any> ? WritableSignal<U> : T[K] extends InputSignal<infer R> ? WritableSignal<R> : T[K];
+};
+export type InjectedState<T> = Signal<State<T>>;
+/**
+ * Create a new injection token for the state.
+ * @param description The description of the token
+ */
+export declare function createStateToken<T>(description: string): InjectionToken<T>;
+/**
+ * Create a new provider for the state. It first tries to inject the state from the parent injector,
+ * as this allows for the state to be hoisted to a higher level in the component tree. This can
+ * be useful to avoid issues where the injector can't be shared in some cases when ng-content is used.
+ * @param token The token for the state
+ */
+export declare function createStateProvider<T>(token: ProviderToken<T>): () => FactoryProvider;
+type CreateStateInjectorOptions = {
+    /**
+     * Whether the state may not be immediately available. This can happen when the child is instantiated before the parent.
+     */
+    deferred?: boolean;
+};
+/**
+ * Create a new state injector for the state.
+ * @param token The token for the state
+ */
+export declare function createStateInjector<T>(token: ProviderToken<State<T>>, options: {
+    deferred: true;
+}): <U = T>() => Signal<State<U> | undefined>;
+export declare function createStateInjector<T>(token: ProviderToken<State<T>>, options?: CreateStateInjectorOptions): <U = T>() => Signal<State<U>>;
+/**
+ * Convert the original state object into a writable state object.
+ * @param token The token for the state
+ */
+export declare function createState(token: ProviderToken<WritableSignal<State<unknown>>>): <U>(state: U) => State<U>;
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@ng-primitives/state",
+  "description": "Angular Primitives State is a low-level state library with a focus on developer experience.",
+  "license": "Apache-2.0",
+  "version": "0.29.0",
+  "keywords": [
+    "angular",
+    "primitives",
+    "state",
+    "cdk"
+  ],
+  "homepage": "https://angularprimitives.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ng-primitives/ng-primitives.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ng-primitives/ng-primitives/issues"
+  },
+  "author": {
+    "name": "Ashley Hunter",
+    "url": "https://github.com/ashley-hunter"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/ng-primitives"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=19.0.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ng-primitives-state.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/ng-primitives-state.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}