@angular-architects/ngrx-toolkit 0.0.2 → 0.0.3

package/esm2022/lib/with-redux.mjs

@@ -92,4 +92,4 @@ export function withRedux(redux) {
         };
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-redux.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-redux.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, Subscription } from 'rxjs';\nimport { SignalStoreFeature } from '@ngrx/signals';\nimport {\n  EmptyFeatureResult,\n  SignalStoreFeatureResult,\n} from '@ngrx/signals/src/signal-store-models';\nimport { StateSignal } from '@ngrx/signals/src/state-signal';\nimport { assertActionFnSpecs } from './assertions/assertions';\nimport { effect } from '@angular/core';\n\n/** Actions **/\n\ntype Payload = Record<string, unknown>;\n\ntype ActionFn<\n  Type extends string = string,\n  ActionPayload extends Payload = Payload\n> = ((payload: ActionPayload) => ActionPayload & { type: Type }) & {\n  type: Type;\n};\n\ntype ActionFns = Record<string, ActionFn>;\n\nexport type ActionsFnSpecs = Record<string, Payload>;\n\ntype ActionFnCreator<Spec extends ActionsFnSpecs> = {\n  [ActionName in keyof Spec]: ((\n    payload: Spec[ActionName]\n  ) => Spec[ActionName] & { type: ActionName }) & { type: ActionName & string };\n};\n\ntype ActionFnPayload<Action> = Action extends (payload: infer Payload) => void\n  ? Payload\n  : never;\n\ntype ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {\n  private: Record<string, Payload>;\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\ntype PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\nexport function payload<Type extends Payload>(): Type {\n  return {} as Type;\n}\n\nexport const noPayload = {};\n\n/** Reducer **/\n\ntype ReducerFunction<ReducerAction, State> = (\n  action: ActionFnPayload<ReducerAction>,\n  state: State\n) => void;\n\ntype ReducerFactory<StateActionFns extends ActionFns, State> = (\n  actions: StateActionFns,\n  on: <ReducerAction extends { type: string }>(\n    action: ReducerAction,\n    reducerFn: ReducerFunction<ActionFnPayload<ReducerAction>, State>\n  ) => void\n) => void;\n\n/** Effect **/\n\ntype EffectsFactory<StateActionFns extends ActionFns> = (\n  actions: StateActionFns,\n  create: <EffectAction extends { type: string }>(\n    action: EffectAction\n  ) => Observable<ActionFnPayload<EffectAction>>\n) => Record<string, Observable<unknown>>;\n\nfunction createActionFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n) {\n  const actionFns: Record<string, ActionFn> = {};\n\n  for (const type in actionFnSpecs) {\n    const actionFn = (payload: Payload) => {\n      const fullPayload = { ...payload, type };\n      const reducer = reducerRegistry[type];\n      if (reducer) {\n        (reducer as (payload: unknown, state: unknown) => void)(\n          fullPayload as unknown,\n          state\n        );\n      }\n      const effectSubject = effectsRegistry[type];\n      if (effectSubject) {\n        (effectSubject as unknown as Subject<unknown>).next(fullPayload);\n      }\n      return fullPayload;\n    };\n    actionFn.type = type.toString();\n    actionFns[type] = actionFn;\n  }\n\n  return actionFns;\n}\n\nfunction createPublicAndAllActionsFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n): { all: ActionFns; publics: ActionFns } {\n  if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {\n    const privates = actionFnSpecs['private'] || {};\n    const publics = actionFnSpecs['public'] || {};\n\n    assertActionFnSpecs(privates);\n    assertActionFnSpecs(publics);\n\n    const privateActionFns = createActionFns(\n      privates,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n    const publicActionFns = createActionFns(\n      publics,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n\n    return {\n      all: { ...privateActionFns, ...publicActionFns },\n      publics: publicActionFns,\n    };\n  }\n\n  const actionFns = createActionFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    state\n  );\n\n  return { all: actionFns, publics: actionFns };\n}\n\nfunction fillReducerRegistry(\n  reducer: ReducerFactory<ActionFns, unknown>,\n  actionFns: ActionFns,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >\n) {\n  function on(\n    action: { type: string },\n    reducerFn: (payload: ActionFnPayload<unknown>, state: unknown) => void\n  ) {\n    reducerRegistry[action.type] = reducerFn;\n  }\n\n  reducer(actionFns, on);\n\n  return reducerRegistry;\n}\n\nfunction fillEffects(\n  effects: EffectsFactory<ActionFns>,\n  actionFns: ActionFns,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {}\n): Observable<unknown>[] {\n  function create(action: { type: string }) {\n    const subject = new Subject<ActionFnPayload<unknown>>();\n    effectsRegistry[action.type] = subject;\n    return subject.asObservable();\n  }\n\n  const effectObservables = effects(actionFns, create);\n  return Object.values(effectObservables);\n}\n\nfunction startSubscriptions(observables: Observable<unknown>[]) {\n  return observables.map((observable) => observable.subscribe());\n}\n\nfunction processRedux<Spec extends ActionsFnSpecs, ReturnType>(\n  actionFnSpecs: Spec,\n  reducer: ReducerFactory<ActionFns, unknown>,\n  effects: EffectsFactory<ActionFns>,\n  store: unknown\n) {\n  const reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  > = {};\n  const effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {};\n  const actionsMap = createPublicAndAllActionsFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    store\n  );\n  const actionFns = actionsMap.all;\n  const publicActionsFns = actionsMap.publics;\n\n  fillReducerRegistry(reducer, actionFns, reducerRegistry);\n  const effectObservables = fillEffects(effects, actionFns, effectsRegistry);\n  const subscriptions = startSubscriptions(effectObservables);\n\n  return {\n    methods: publicActionsFns as ReturnType,\n    subscriptions: subscriptions,\n  };\n}\n\n/**\n * @param redux redux\n *\n * properties do not start with `with` since they are not extension functions on their own.\n *\n * no dependency to NgRx\n *\n * actions are passed to reducer and effects, but it is also possible to use other actions.\n * effects provide forAction and do not return anything. that is important because effects should stay inaccessible\n */\nexport function withRedux<\n  Spec extends ActionsFnSpecs,\n  Input extends SignalStoreFeatureResult,\n  StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>,\n  PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>\n>(redux: {\n  actions: Spec;\n  reducer: ReducerFactory<StateActionFns, StateSignal<Input['state']>>;\n  effects: EffectsFactory<StateActionFns>;\n}): SignalStoreFeature<\n  Input,\n  EmptyFeatureResult & { methods: PublicStoreActionFns }\n> {\n  return (store) => {\n    const { methods, subscriptions } = processRedux<Spec, PublicStoreActionFns>(\n      redux.actions,\n      redux.reducer as ReducerFactory<ActionFns, unknown>,\n      redux.effects as EffectsFactory<ActionFns>,\n      store\n    );\n    return {\n      ...store,\n      methods,\n    };\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-redux.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-redux.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, Subscription } from 'rxjs';\r\nimport { SignalStoreFeature } from '@ngrx/signals';\r\nimport {\r\n  EmptyFeatureResult,\r\n  SignalStoreFeatureResult,\r\n} from '@ngrx/signals/src/signal-store-models';\r\nimport { StateSignal } from '@ngrx/signals/src/state-signal';\r\nimport { assertActionFnSpecs } from './assertions/assertions';\r\nimport { effect } from '@angular/core';\r\n\r\n/** Actions **/\r\n\r\ntype Payload = Record<string, unknown>;\r\n\r\ntype ActionFn<\r\n  Type extends string = string,\r\n  ActionPayload extends Payload = Payload\r\n> = ((payload: ActionPayload) => ActionPayload & { type: Type }) & {\r\n  type: Type;\r\n};\r\n\r\ntype ActionFns = Record<string, ActionFn>;\r\n\r\nexport type ActionsFnSpecs = Record<string, Payload>;\r\n\r\ntype ActionFnCreator<Spec extends ActionsFnSpecs> = {\r\n  [ActionName in keyof Spec]: ((\r\n    payload: Spec[ActionName]\r\n  ) => Spec[ActionName] & { type: ActionName }) & { type: ActionName & string };\r\n};\r\n\r\ntype ActionFnPayload<Action> = Action extends (payload: infer Payload) => void\r\n  ? Payload\r\n  : never;\r\n\r\ntype ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {\r\n  private: Record<string, Payload>;\r\n  public: Record<string, Payload>;\r\n}\r\n  ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']>\r\n  : ActionFnCreator<Spec>;\r\n\r\ntype PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {\r\n  public: Record<string, Payload>;\r\n}\r\n  ? ActionFnCreator<Spec['public']>\r\n  : ActionFnCreator<Spec>;\r\n\r\nexport function payload<Type extends Payload>(): Type {\r\n  return {} as Type;\r\n}\r\n\r\nexport const noPayload = {};\r\n\r\n/** Reducer **/\r\n\r\ntype ReducerFunction<ReducerAction, State> = (\r\n  action: ActionFnPayload<ReducerAction>,\r\n  state: State\r\n) => void;\r\n\r\ntype ReducerFactory<StateActionFns extends ActionFns, State> = (\r\n  actions: StateActionFns,\r\n  on: <ReducerAction extends { type: string }>(\r\n    action: ReducerAction,\r\n    reducerFn: ReducerFunction<ActionFnPayload<ReducerAction>, State>\r\n  ) => void\r\n) => void;\r\n\r\n/** Effect **/\r\n\r\ntype EffectsFactory<StateActionFns extends ActionFns> = (\r\n  actions: StateActionFns,\r\n  create: <EffectAction extends { type: string }>(\r\n    action: EffectAction\r\n  ) => Observable<ActionFnPayload<EffectAction>>\r\n) => Record<string, Observable<unknown>>;\r\n\r\nfunction createActionFns<Spec extends ActionsFnSpecs>(\r\n  actionFnSpecs: Spec,\r\n  reducerRegistry: Record<\r\n    string,\r\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\r\n  >,\r\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\r\n  state: unknown\r\n) {\r\n  const actionFns: Record<string, ActionFn> = {};\r\n\r\n  for (const type in actionFnSpecs) {\r\n    const actionFn = (payload: Payload) => {\r\n      const fullPayload = { ...payload, type };\r\n      const reducer = reducerRegistry[type];\r\n      if (reducer) {\r\n        (reducer as (payload: unknown, state: unknown) => void)(\r\n          fullPayload as unknown,\r\n          state\r\n        );\r\n      }\r\n      const effectSubject = effectsRegistry[type];\r\n      if (effectSubject) {\r\n        (effectSubject as unknown as Subject<unknown>).next(fullPayload);\r\n      }\r\n      return fullPayload;\r\n    };\r\n    actionFn.type = type.toString();\r\n    actionFns[type] = actionFn;\r\n  }\r\n\r\n  return actionFns;\r\n}\r\n\r\nfunction createPublicAndAllActionsFns<Spec extends ActionsFnSpecs>(\r\n  actionFnSpecs: Spec,\r\n  reducerRegistry: Record<\r\n    string,\r\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\r\n  >,\r\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\r\n  state: unknown\r\n): { all: ActionFns; publics: ActionFns } {\r\n  if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {\r\n    const privates = actionFnSpecs['private'] || {};\r\n    const publics = actionFnSpecs['public'] || {};\r\n\r\n    assertActionFnSpecs(privates);\r\n    assertActionFnSpecs(publics);\r\n\r\n    const privateActionFns = createActionFns(\r\n      privates,\r\n      reducerRegistry,\r\n      effectsRegistry,\r\n      state\r\n    );\r\n    const publicActionFns = createActionFns(\r\n      publics,\r\n      reducerRegistry,\r\n      effectsRegistry,\r\n      state\r\n    );\r\n\r\n    return {\r\n      all: { ...privateActionFns, ...publicActionFns },\r\n      publics: publicActionFns,\r\n    };\r\n  }\r\n\r\n  const actionFns = createActionFns(\r\n    actionFnSpecs,\r\n    reducerRegistry,\r\n    effectsRegistry,\r\n    state\r\n  );\r\n\r\n  return { all: actionFns, publics: actionFns };\r\n}\r\n\r\nfunction fillReducerRegistry(\r\n  reducer: ReducerFactory<ActionFns, unknown>,\r\n  actionFns: ActionFns,\r\n  reducerRegistry: Record<\r\n    string,\r\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\r\n  >\r\n) {\r\n  function on(\r\n    action: { type: string },\r\n    reducerFn: (payload: ActionFnPayload<unknown>, state: unknown) => void\r\n  ) {\r\n    reducerRegistry[action.type] = reducerFn;\r\n  }\r\n\r\n  reducer(actionFns, on);\r\n\r\n  return reducerRegistry;\r\n}\r\n\r\nfunction fillEffects(\r\n  effects: EffectsFactory<ActionFns>,\r\n  actionFns: ActionFns,\r\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {}\r\n): Observable<unknown>[] {\r\n  function create(action: { type: string }) {\r\n    const subject = new Subject<ActionFnPayload<unknown>>();\r\n    effectsRegistry[action.type] = subject;\r\n    return subject.asObservable();\r\n  }\r\n\r\n  const effectObservables = effects(actionFns, create);\r\n  return Object.values(effectObservables);\r\n}\r\n\r\nfunction startSubscriptions(observables: Observable<unknown>[]) {\r\n  return observables.map((observable) => observable.subscribe());\r\n}\r\n\r\nfunction processRedux<Spec extends ActionsFnSpecs, ReturnType>(\r\n  actionFnSpecs: Spec,\r\n  reducer: ReducerFactory<ActionFns, unknown>,\r\n  effects: EffectsFactory<ActionFns>,\r\n  store: unknown\r\n) {\r\n  const reducerRegistry: Record<\r\n    string,\r\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\r\n  > = {};\r\n  const effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {};\r\n  const actionsMap = createPublicAndAllActionsFns(\r\n    actionFnSpecs,\r\n    reducerRegistry,\r\n    effectsRegistry,\r\n    store\r\n  );\r\n  const actionFns = actionsMap.all;\r\n  const publicActionsFns = actionsMap.publics;\r\n\r\n  fillReducerRegistry(reducer, actionFns, reducerRegistry);\r\n  const effectObservables = fillEffects(effects, actionFns, effectsRegistry);\r\n  const subscriptions = startSubscriptions(effectObservables);\r\n\r\n  return {\r\n    methods: publicActionsFns as ReturnType,\r\n    subscriptions: subscriptions,\r\n  };\r\n}\r\n\r\n/**\r\n * @param redux redux\r\n *\r\n * properties do not start with `with` since they are not extension functions on their own.\r\n *\r\n * no dependency to NgRx\r\n *\r\n * actions are passed to reducer and effects, but it is also possible to use other actions.\r\n * effects provide forAction and do not return anything. that is important because effects should stay inaccessible\r\n */\r\nexport function withRedux<\r\n  Spec extends ActionsFnSpecs,\r\n  Input extends SignalStoreFeatureResult,\r\n  StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>,\r\n  PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>\r\n>(redux: {\r\n  actions: Spec;\r\n  reducer: ReducerFactory<StateActionFns, StateSignal<Input['state']>>;\r\n  effects: EffectsFactory<StateActionFns>;\r\n}): SignalStoreFeature<\r\n  Input,\r\n  EmptyFeatureResult & { methods: PublicStoreActionFns }\r\n> {\r\n  return (store) => {\r\n    const { methods, subscriptions } = processRedux<Spec, PublicStoreActionFns>(\r\n      redux.actions,\r\n      redux.reducer as ReducerFactory<ActionFns, unknown>,\r\n      redux.effects as EffectsFactory<ActionFns>,\r\n      store\r\n    );\r\n    return {\r\n      ...store,\r\n      methods,\r\n    };\r\n  };\r\n}\r\n"]}

package/esm2022/lib/with-undo-redo.mjs

@@ -0,0 +1,93 @@
+import { patchState, signalStoreFeature, withComputed, withHooks, withMethods } from "@ngrx/signals";
+import { effect, signal, untracked, isSignal } from "@angular/core";
+import { capitalize } from "./with-data-service";
+const defaultOptions = {
+    maxStackSize: 100
+};
+export function getUndoRedoKeys(collections) {
+    if (collections) {
+        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize(c)}Ids`, `${c}Filter`]);
+    }
+    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+}
+export function withUndoRedo(options = {}) {
+    let previous = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions,
+        ...options
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    const updateInternal = () => {
+        canUndo.set(undoStack.length !== 0);
+        canRedo.set(redoStack.length !== 0);
+    };
+    const keys = getUndoRedoKeys(normalized?.collections);
+    return signalStoreFeature(withComputed(() => ({
+        canUndo: canUndo.asReadonly(),
+        canRedo: canRedo.asReadonly()
+    })), withMethods((store) => ({
+        undo() {
+            const item = undoStack.pop();
+            if (item && previous) {
+                redoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && previous) {
+                undoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState(store, item);
+                previous = item;
+            }
+            updateInternal();
+        }
+    })), withHooks({
+        onInit(store) {
+            effect(() => {
+                const cand = keys.reduce((acc, key) => {
+                    const s = store[key];
+                    if (s && isSignal(s)) {
+                        return {
+                            ...acc,
+                            [key]: s()
+                        };
+                    }
+                    return acc;
+                }, {});
+                if (skipOnce) {
+                    skipOnce = false;
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (previous) {
+                    undoStack.push(previous);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                previous = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        }
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-undo-redo.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-undo-redo.ts"],"names":[],"mappings":"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","sourcesContent":["import { SignalStoreFeature, patchState, signalStoreFeature, withComputed, withHooks, withMethods } from \"@ngrx/signals\";\r\nimport { EntityId, EntityMap, EntityState } from \"@ngrx/signals/entities\";\r\nimport { Signal, effect, signal, untracked, isSignal } from \"@angular/core\";\r\nimport { EntitySignals, NamedEntitySignals } from \"@ngrx/signals/entities/src/models\";\r\nimport { Entity, capitalize } from \"./with-data-service\";\r\nimport { Emtpy } from \"./shared/empty\";\r\n\r\nexport type StackItem = Record<string, unknown>;\r\n\r\nexport type NormalizedUndoRedoOptions = {\r\n    maxStackSize: number;\r\n    collections?: string[]\r\n}\r\n\r\nconst defaultOptions: NormalizedUndoRedoOptions = {\r\n    maxStackSize: 100\r\n};\r\n\r\nexport type NamedUndoRedoState<Collection extends string> = {\r\n    [K in Collection as `${K}EntityMap`]: EntityMap<Entity>;\r\n} & {\r\n        [K in Collection as `${K}Ids`]: EntityId[];\r\n    }\r\n\r\nexport type NamedUndoRedoSignals<Collection extends string> = {\r\n    [K in Collection as `${K}Entities`]: Signal<Entity[]>\r\n}\r\n\r\nexport function getUndoRedoKeys(collections?: string[]): string[] {\r\n    if (collections) {\r\n        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize(c)}Ids`, `${c}Filter`])\r\n    }\r\n    return ['entityMap', 'ids', 'selectedIds', 'filter'];\r\n}\r\n\r\nexport function withUndoRedo<Collection extends string>(options?: { maxStackSize?: number; collections: Collection[] }): SignalStoreFeature<\r\n    {\r\n        state: Emtpy,\r\n        // This alternative breaks type inference:\r\n        // state: NamedEntityState<Entity, Collection>\r\n        signals: NamedEntitySignals<Entity, Collection>,\r\n        methods: Emtpy\r\n    },\r\n    {\r\n        state: Emtpy,\r\n        signals: {\r\n            canUndo: Signal<boolean>,\r\n            canRedo: Signal<boolean>\r\n        },\r\n        methods: {\r\n            undo: () => void,\r\n            redo: () => void\r\n        }\r\n    }>;\r\n\r\nexport function withUndoRedo(options?: { maxStackSize?: number }): SignalStoreFeature<\r\n    {\r\n        state: EntityState<Entity>,\r\n        signals: EntitySignals<Entity>,\r\n        methods: Emtpy\r\n    },\r\n    {\r\n        state: Emtpy,\r\n        signals: {\r\n            canUndo: Signal<boolean>,\r\n            canRedo: Signal<boolean>\r\n        },\r\n        methods: {\r\n            undo: () => void,\r\n            redo: () => void\r\n        }\r\n    }>;\r\n\r\nexport function withUndoRedo<Collection extends string>(options: {\r\n    maxStackSize?: number;\r\n    collections?: Collection[]\r\n} = {}): \r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nSignalStoreFeature<any, any> {\r\n    let previous: StackItem | null = null;\r\n    let skipOnce = false;\r\n\r\n    const normalized = {\r\n        ...defaultOptions,\r\n        ...options\r\n    };\r\n\r\n    //\r\n    // Design Decision: This feature has its own\r\n    // internal state.\r\n    //\r\n\r\n    const undoStack: StackItem[] = [];\r\n    const redoStack: StackItem[] = [];\r\n\r\n    const canUndo = signal(false);\r\n    const canRedo = signal(false);\r\n\r\n    const updateInternal = () => {\r\n        canUndo.set(undoStack.length !== 0);\r\n        canRedo.set(redoStack.length !== 0);\r\n    };\r\n\r\n    const keys = getUndoRedoKeys(normalized?.collections);\r\n\r\n    return signalStoreFeature(\r\n\r\n        withComputed(() => ({\r\n            canUndo: canUndo.asReadonly(),\r\n            canRedo: canRedo.asReadonly()\r\n        })),\r\n        withMethods((store) => ({\r\n            undo(): void {\r\n                const item = undoStack.pop();\r\n\r\n                if (item && previous) {\r\n                    redoStack.push(previous);\r\n                }\r\n\r\n                if (item) {\r\n                    skipOnce = true;\r\n                    patchState(store, item);\r\n                    previous = item;\r\n                }\r\n\r\n                updateInternal();\r\n            },\r\n            redo(): void {\r\n                const item = redoStack.pop();\r\n\r\n                if (item && previous) {\r\n                    undoStack.push(previous);\r\n                }\r\n\r\n                if (item) {\r\n                    skipOnce = true;\r\n                    patchState(store, item);\r\n                    previous = item;\r\n                }\r\n\r\n                updateInternal();\r\n            }\r\n        })),\r\n        withHooks({\r\n            onInit(store: Record<string, unknown>) {\r\n                effect(() => {\r\n\r\n                    const cand = keys.reduce((acc, key) => {\r\n                        const s = store[key];\r\n                        if (s && isSignal(s)) {\r\n                            return {\r\n                                ...acc,\r\n                                [key]: s()\r\n                            }\r\n                        }\r\n                        return acc;\r\n                    }, {});\r\n\r\n                    if (skipOnce) {\r\n                        skipOnce = false;\r\n                        return;\r\n                    }\r\n\r\n                    // Clear redoStack after recorded action\r\n                    redoStack.splice(0);\r\n\r\n                    if (previous) {\r\n                        undoStack.push(previous);\r\n                    }\r\n\r\n                    if (redoStack.length > normalized.maxStackSize) {\r\n                        undoStack.unshift();\r\n                    }\r\n\r\n                    previous = cand;\r\n\r\n                    // Don't propogate current reactive context\r\n                    untracked(() => updateInternal());\r\n                })\r\n            }\r\n        })\r\n\r\n    )\r\n}\r\n"]}

package/fesm2022/angular-architects-ngrx-toolkit.mjs

@@ -1,7 +1,8 @@
-import { patchState as patchState$1 } from '@ngrx/signals';
-import { signal, effect, PLATFORM_ID, inject } from '@angular/core';
+import { patchState as patchState$1, withState, withComputed, signalStoreFeature, withMethods, withHooks } from '@ngrx/signals';
+import { signal, effect, PLATFORM_ID, inject, computed, isSignal, untracked } from '@angular/core';
 import { isPlatformServer } from '@angular/common';
 import { Subject } from 'rxjs';
+import { setAllEntities, addEntity, updateEntity, removeEntity } from '@ngrx/signals/entities';
 
 const storeRegistry = signal({});
 let currentActionNames = new Set();
@@ -178,9 +179,298 @@ function withRedux(redux) {
     };
 }
 
+function getCallStateKeys(config) {
+    const prop = config?.collection;
+    return {
+        callStateKey: prop ? `${config.collection}CallState` : 'callState',
+        loadingKey: prop ? `${config.collection}Loading` : 'loading',
+        loadedKey: prop ? `${config.collection}Loaded` : 'loaded',
+        errorKey: prop ? `${config.collection}Error` : 'error',
+    };
+}
+function withCallState(config) {
+    const { callStateKey, errorKey, loadedKey, loadingKey } = getCallStateKeys(config);
+    return signalStoreFeature(withState({ [callStateKey]: 'init' }), withComputed((state) => {
+        const callState = state[callStateKey];
+        return {
+            [loadingKey]: computed(() => callState() === 'loading'),
+            [loadedKey]: computed(() => callState() === 'loaded'),
+            [errorKey]: computed(() => {
+                const v = callState();
+                return typeof v === 'object' ? v.error : null;
+            })
+        };
+    }));
+}
+function setLoading(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loading' };
+    }
+    return { callState: 'loading' };
+}
+function setLoaded(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loaded' };
+    }
+    else {
+        return { callState: 'loaded' };
+    }
+}
+function setError(error, prop) {
+    let errorMessage = '';
+    if (!error) {
+        errorMessage = '';
+    }
+    else if (typeof error === 'object' && 'message' in error) {
+        errorMessage = String(error.message);
+    }
+    else {
+        errorMessage = String(error);
+    }
+    if (prop) {
+        return { [`${prop}CallState`]: { error: errorMessage } };
+    }
+    else {
+        return { callState: { error: errorMessage } };
+    }
+}
+
+function capitalize(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+function getDataServiceKeys(options) {
+    const filterKey = options.collection ? `${options.collection}Filter` : 'filter';
+    const selectedIdsKey = options.collection ? `selected${capitalize(options.collection)}Ids` : 'selectedIds';
+    const selectedEntitiesKey = options.collection ? `selected${capitalize(options.collection)}Entities` : 'selectedEntities';
+    const updateFilterKey = options.collection ? `update${capitalize(options.collection)}Filter` : 'updateFilter';
+    const updateSelectedKey = options.collection ? `updateSelected${capitalize(options.collection)}Entities` : 'updateSelected';
+    const loadKey = options.collection ? `load${capitalize(options.collection)}Entities` : 'load';
+    const currentKey = options.collection ? `current${capitalize(options.collection)}` : 'current';
+    const loadByIdKey = options.collection ? `load${capitalize(options.collection)}ById` : 'loadById';
+    const setCurrentKey = options.collection ? `setCurrent${capitalize(options.collection)}` : 'setCurrent';
+    const createKey = options.collection ? `create${capitalize(options.collection)}` : 'create';
+    const updateKey = options.collection ? `update${capitalize(options.collection)}` : 'update';
+    const deleteKey = options.collection ? `delete${capitalize(options.collection)}` : 'delete';
+    // TODO: Take these from @ngrx/signals/entities, when they are exported
+    const entitiesKey = options.collection ? `${options.collection}Entities` : 'entities';
+    const entityMapKey = options.collection ? `${options.collection}EntityMap` : 'entityMap';
+    const idsKey = options.collection ? `${options.collection}Ids` : 'ids';
+    return {
+        filterKey,
+        selectedIdsKey,
+        selectedEntitiesKey,
+        updateFilterKey,
+        updateSelectedKey,
+        loadKey,
+        entitiesKey,
+        entityMapKey,
+        idsKey,
+        currentKey,
+        loadByIdKey,
+        setCurrentKey,
+        createKey,
+        updateKey,
+        deleteKey
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function withDataService(options) {
+    const { dataServiceType, filter, collection: prefix } = options;
+    const { entitiesKey, filterKey, loadKey, selectedEntitiesKey, selectedIdsKey, updateFilterKey, updateSelectedKey, currentKey, createKey, updateKey, deleteKey, loadByIdKey, setCurrentKey } = getDataServiceKeys(options);
+    const { callStateKey } = getCallStateKeys({ collection: prefix });
+    return signalStoreFeature(withState(() => ({
+        [filterKey]: filter,
+        [selectedIdsKey]: {},
+        [currentKey]: undefined
+    })), withComputed((store) => {
+        const entities = store[entitiesKey];
+        const selectedIds = store[selectedIdsKey];
+        return {
+            [selectedEntitiesKey]: computed(() => entities().filter(e => selectedIds()[e.id]))
+        };
+    }), withMethods((store) => {
+        const dataService = inject(dataServiceType);
+        return {
+            [updateFilterKey]: (filter) => {
+                patchState$1(store, { [filterKey]: filter });
+            },
+            [updateSelectedKey]: (id, selected) => {
+                patchState$1(store, (state) => ({
+                    [selectedIdsKey]: {
+                        ...state[selectedIdsKey],
+                        [id]: selected,
+                    }
+                }));
+            },
+            [loadKey]: async () => {
+                const filter = store[filterKey];
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const result = await dataService.load(filter());
+                    patchState$1(store, prefix ? setAllEntities(result, { collection: prefix }) : setAllEntities(result));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [loadByIdKey]: async (id) => {
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const current = await dataService.loadById(id);
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    patchState$1(store, { [currentKey]: current });
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [setCurrentKey]: (current) => {
+                patchState$1(store, { [currentKey]: current });
+            },
+            [createKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const created = await dataService.create(entity);
+                    patchState$1(store, { [currentKey]: created });
+                    patchState$1(store, prefix ? addEntity(created, { collection: prefix }) : addEntity(created));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [updateKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const updated = await dataService.update(entity);
+                    patchState$1(store, { [currentKey]: updated });
+                    // Why do we need this cast to Partial<Entity>?
+                    const updateArg = { id: updated.id, changes: updated };
+                    patchState$1(store, prefix ? updateEntity(updateArg, { collection: prefix }) : updateEntity(updateArg));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [deleteKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    await dataService.delete(entity);
+                    patchState$1(store, { [currentKey]: undefined });
+                    patchState$1(store, prefix ? removeEntity(entity.id, { collection: prefix }) : removeEntity(entity.id));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+        };
+    }));
+}
+
+const defaultOptions = {
+    maxStackSize: 100
+};
+function getUndoRedoKeys(collections) {
+    if (collections) {
+        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize(c)}Ids`, `${c}Filter`]);
+    }
+    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+}
+function withUndoRedo(options = {}) {
+    let previous = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions,
+        ...options
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    const updateInternal = () => {
+        canUndo.set(undoStack.length !== 0);
+        canRedo.set(redoStack.length !== 0);
+    };
+    const keys = getUndoRedoKeys(normalized?.collections);
+    return signalStoreFeature(withComputed(() => ({
+        canUndo: canUndo.asReadonly(),
+        canRedo: canRedo.asReadonly()
+    })), withMethods((store) => ({
+        undo() {
+            const item = undoStack.pop();
+            if (item && previous) {
+                redoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && previous) {
+                undoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        }
+    })), withHooks({
+        onInit(store) {
+            effect(() => {
+                const cand = keys.reduce((acc, key) => {
+                    const s = store[key];
+                    if (s && isSignal(s)) {
+                        return {
+                            ...acc,
+                            [key]: s()
+                        };
+                    }
+                    return acc;
+                }, {});
+                if (skipOnce) {
+                    skipOnce = false;
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (previous) {
+                    undoStack.push(previous);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                previous = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        }
+    }));
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { noPayload, patchState, payload, withDevtools, withRedux };
+export { capitalize, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, noPayload, patchState, payload, setError, setLoaded, setLoading, withCallState, withDataService, withDevtools, withRedux, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map