@genesislcap/foundation-redux 14.310.0

package/dist/foundation-redux.d.ts

@@ -0,0 +1,222 @@
+import { Action } from '@reduxjs/toolkit';
+import { createSlice } from '@reduxjs/toolkit';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { Reducer } from '@reduxjs/toolkit';
+import { ReducersMapObject } from '@reduxjs/toolkit';
+import { ThunkAction } from '@reduxjs/toolkit';
+
+/**
+ * Extracts the bound actions type from an array of slices.
+ *
+ * @remarks
+ * This utility type creates a nested object structure where each slice name maps to its actions.
+ * Actions are bound to the store and automatically dispatch when called.
+ *
+ * @example
+ * ```typescript
+ * const { actions } = createStore([userSlice, cartSlice], initialState);
+ * // actions.user.setUser({ name: 'John' })
+ * // actions.cart.addItem({ id: 'item1', quantity: 1 })
+ * ```
+ *
+ * @public
+ */
+export declare type ActionsFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: {
+        [ActionKey in keyof Extract<S[number], {
+            name: K;
+        }>['actions']]: (payload: FirstParameter<Extract<S[number], {
+            name: K;
+        }>['actions'][ActionKey]>) => void;
+    };
+};
+
+export { createSlice }
+
+/**
+ * Creates a Redux store with FAST component integration.
+ *
+ * @remarks
+ * This function creates a Redux store that integrates seamlessly with FAST components.
+ * It automatically binds actions and selectors, provides subscription methods, and handles
+ * FAST Observable notifications.
+ *
+ * @param slices - Array of slices to combine into the store
+ * @param preloadedState - Initial state that matches the slice structure
+ * @returns Object containing store, actions, selectors, and utility functions
+ *
+ * @example
+ * ```typescript
+ * const { store, actions, selectors, subscribeKey } = createStore(
+ *   [userSlice, cartSlice],
+ *   {
+ *     user: { name: '', email: '' },
+ *     cart: { items: [], total: 0 }
+ *   }
+ * );
+ * ```
+ *
+ * @public
+ */
+export declare const createStore: <S extends SliceArray>(slices: S, preloadedState: RootStateFromSlices<S>) => StoreReturn<S>;
+
+declare type FirstIndex = 0;
+
+declare type FirstParameter<T> = T extends (...args: infer P) => any ? P[FirstIndex] : never;
+
+export { PayloadAction }
+
+declare type RemoveFirstParameter<T> = T extends (arg1: any, ...rest: infer Rest) => any ? Rest : never;
+
+/**
+ * Extracts the root state type from an array of slices.
+ *
+ * @remarks
+ * This utility type maps over the slice names and extracts the state type for each slice.
+ * The resulting type represents the complete state structure of your Redux store.
+ *
+ * @example
+ * ```typescript
+ * const slices = [userSlice, cartSlice];
+ * type RootState = RootStateFromSlices<typeof slices>;
+ * // Result: { user: UserState, cart: CartState }
+ * ```
+ *
+ * @public
+ */
+export declare type RootStateFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: Extract<S[number], {
+        name: K;
+    }> extends Slice<infer State> ? State : never;
+};
+
+/**
+ * Extracts the bound selectors type from an array of slices.
+ *
+ * @remarks
+ * This utility type creates a nested object structure where each slice name maps to its selectors.
+ * Selectors are bound to the store and can access the current state.
+ *
+ * @example
+ * ```typescript
+ * const { selectors } = createStore([userSlice, cartSlice], initialState);
+ * // const userName = selectors.user.getUserName()
+ * // const cartTotal = selectors.cart.getTotal()
+ * ```
+ *
+ * @public
+ */
+export declare type SelectorsFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: {
+        [SelectorKey in keyof Extract<S[number], {
+            name: K;
+        }>['selectors']]: (...payload: RemoveFirstParameter<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]>) => ReturnType<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]> extends void ? any : ReturnType<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]>;
+    };
+};
+
+/**
+ * Represents a Redux slice with actions and selectors.
+ *
+ * @remarks
+ * A slice contains the reducer, actions, and selectors for a specific domain of your application state.
+ *
+ * @example
+ * ```typescript
+ * const userSlice: Slice = {
+ *   name: 'user',
+ *   reducer: userReducer,
+ *   actions: { setUser, logout },
+ *   selectors: { getUser, isLoggedIn }
+ * };
+ * ```
+ *
+ * @public
+ */
+export declare interface Slice<State = any> {
+    /** The unique name of the slice */
+    name: string;
+    /** The Redux reducer function for this slice */
+    reducer: Reducer<State, Action>;
+    /** Action creators for this slice */
+    actions: Record<string, (payload: any) => Action>;
+    /** Selector functions for this slice */
+    selectors: Record<string, (...args: any[]) => any>;
+}
+
+/**
+ * An array of slices that will be combined into a single store.
+ *
+ * @remarks
+ * This type represents the collection of slices that will be used to create a Redux store.
+ * Each slice in the array will become a top-level key in the store's state.
+ *
+ * @example
+ * ```typescript
+ * const slices: SliceArray = [userSlice, cartSlice, preferencesSlice];
+ * const { store } = createStore(slices, initialState);
+ * ```
+ *
+ * @public
+ */
+export declare type SliceArray = Slice[];
+
+/**
+ * The return type of the createStore function.
+ *
+ * @remarks
+ * This type represents all the utilities and functions returned when creating a store.
+ * It provides access to the store state, actions, selectors, and subscription methods.
+ *
+ * @example
+ * ```typescript
+ * const { store, actions, selectors, subscribeKey } = createStore(slices, initialState);
+ * ```
+ *
+ * @public
+ */
+export declare type StoreReturn<S extends SliceArray> = {
+    /** Proxy object for accessing slice state */
+    store: RootStateFromSlices<S>;
+    /** Bound actions for each slice */
+    actions: ActionsFromSlices<S>;
+    /** Bound selectors for each slice */
+    selectors: SelectorsFromSlices<S>;
+    /** The root reducer combining all slices */
+    rootReducer: ReducersMapObject<RootStateFromSlices<S>>;
+    /** Performance-optimized subscription function for specific values */
+    subscribeKey: (checkerFn: (s: RootStateFromSlices<S>) => string, callbackFn: (s: RootStateFromSlices<S>) => void) => void;
+    /** Function to dispatch actions or thunks */
+    dispatch: (action: Action | ThunkDispatch<S>) => void;
+    /** Function to notify FAST components of slice changes */
+    notify: (sliceName: keyof RootStateFromSlices<S>) => void;
+    /** General subscription function for all state changes */
+    subscribe: (cb: (state: RootStateFromSlices<S>) => void) => void;
+    /** Function to get the current state */
+    getState: () => RootStateFromSlices<S>;
+};
+
+/**
+ * Type for thunk actions that can be dispatched to the store.
+ *
+ * @remarks
+ * This type represents thunk actions that can access the store's dispatch and getState functions.
+ * Thunks are useful for handling asynchronous operations and complex logic.
+ *
+ * @example
+ * ```typescript
+ * const fetchUserThunk: ThunkDispatch<typeof slices> = (dispatch, getState) => {
+ *   fetch('/api/user').then(user => dispatch(actions.user.setUser(user)));
+ * };
+ * ```
+ *
+ * @public
+ */
+export declare type ThunkDispatch<S extends SliceArray> = ThunkAction<void, RootStateFromSlices<S>, any, Action>;
+
+export { }

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.52.10"
+    }
+  ]
+}

package/docs/.gitattributes

@@ -0,0 +1,2 @@
+*.md -diff
+*.md linguist-generated

package/docs/api/foundation-redux.actionsfromslices.md

@@ -0,0 +1,36 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md) &gt; [ActionsFromSlices](./foundation-redux.actionsfromslices.md)
+
+## ActionsFromSlices type
+
+Extracts the bound actions type from an array of slices.
+
+**Signature:**
+
+```typescript
+export type ActionsFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: {
+        [ActionKey in keyof Extract<S[number], {
+            name: K;
+        }>['actions']]: (payload: FirstParameter<Extract<S[number], {
+            name: K;
+        }>['actions'][ActionKey]>) => void;
+    };
+};
+```
+**References:** [SliceArray](./foundation-redux.slicearray.md)
+
+## Remarks
+
+This utility type creates a nested object structure where each slice name maps to its actions. Actions are bound to the store and automatically dispatch when called.
+
+## Example
+
+
+```typescript
+const { actions } = createStore([userSlice, cartSlice], initialState);
+// actions.user.setUser({ name: 'John' })
+// actions.cart.addItem({ id: 'item1', quantity: 1 })
+```
+

package/docs/api/foundation-redux.createstore.md

@@ -0,0 +1,89 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md) &gt; [createStore](./foundation-redux.createstore.md)
+
+## createStore() function
+
+Creates a Redux store with FAST component integration.
+
+**Signature:**
+
+```typescript
+createStore: <S extends SliceArray>(slices: S, preloadedState: RootStateFromSlices<S>) => StoreReturn<S>
+```
+
+## Parameters
+
+<table><thead><tr><th>
+
+Parameter
+
+
+</th><th>
+
+Type
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+slices
+
+
+</td><td>
+
+S
+
+
+</td><td>
+
+Array of slices to combine into the store
+
+
+</td></tr>
+<tr><td>
+
+preloadedState
+
+
+</td><td>
+
+[RootStateFromSlices](./foundation-redux.rootstatefromslices.md)<!-- -->&lt;S&gt;
+
+
+</td><td>
+
+Initial state that matches the slice structure
+
+
+</td></tr>
+</tbody></table>
+
+**Returns:**
+
+[StoreReturn](./foundation-redux.storereturn.md)<!-- -->&lt;S&gt;
+
+Object containing store, actions, selectors, and utility functions
+
+## Remarks
+
+This function creates a Redux store that integrates seamlessly with FAST components. It automatically binds actions and selectors, provides subscription methods, and handles FAST Observable notifications.
+
+## Example
+
+
+```typescript
+const { store, actions, selectors, subscribeKey } = createStore(
+  [userSlice, cartSlice],
+  {
+    user: { name: '', email: '' },
+    cart: { items: [], total: 0 }
+  }
+);
+```
+

package/docs/api/foundation-redux.md

@@ -0,0 +1,139 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md)
+
+## foundation-redux package
+
+## Functions
+
+<table><thead><tr><th>
+
+Function
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+[createStore(slices, preloadedState)](./foundation-redux.createstore.md)
+
+
+</td><td>
+
+Creates a Redux store with FAST component integration.
+
+
+</td></tr>
+</tbody></table>
+
+## Interfaces
+
+<table><thead><tr><th>
+
+Interface
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+[Slice](./foundation-redux.slice.md)
+
+
+</td><td>
+
+Represents a Redux slice with actions and selectors.
+
+
+</td></tr>
+</tbody></table>
+
+## Type Aliases
+
+<table><thead><tr><th>
+
+Type Alias
+
+
+</th><th>
+
+Description
+
+
+</th></tr></thead>
+<tbody><tr><td>
+
+[ActionsFromSlices](./foundation-redux.actionsfromslices.md)
+
+
+</td><td>
+
+Extracts the bound actions type from an array of slices.
+
+
+</td></tr>
+<tr><td>
+
+[RootStateFromSlices](./foundation-redux.rootstatefromslices.md)
+
+
+</td><td>
+
+Extracts the root state type from an array of slices.
+
+
+</td></tr>
+<tr><td>
+
+[SelectorsFromSlices](./foundation-redux.selectorsfromslices.md)
+
+
+</td><td>
+
+Extracts the bound selectors type from an array of slices.
+
+
+</td></tr>
+<tr><td>
+
+[SliceArray](./foundation-redux.slicearray.md)
+
+
+</td><td>
+
+An array of slices that will be combined into a single store.
+
+
+</td></tr>
+<tr><td>
+
+[StoreReturn](./foundation-redux.storereturn.md)
+
+
+</td><td>
+
+The return type of the createStore function.
+
+
+</td></tr>
+<tr><td>
+
+[ThunkDispatch](./foundation-redux.thunkdispatch.md)
+
+
+</td><td>
+
+Type for thunk actions that can be dispatched to the store.
+
+
+</td></tr>
+</tbody></table>
+

package/docs/api/foundation-redux.rootstatefromslices.md

@@ -0,0 +1,32 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md) &gt; [RootStateFromSlices](./foundation-redux.rootstatefromslices.md)
+
+## RootStateFromSlices type
+
+Extracts the root state type from an array of slices.
+
+**Signature:**
+
+```typescript
+export type RootStateFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: Extract<S[number], {
+        name: K;
+    }> extends Slice<infer State> ? State : never;
+};
+```
+**References:** [SliceArray](./foundation-redux.slicearray.md)<!-- -->, [Slice](./foundation-redux.slice.md)
+
+## Remarks
+
+This utility type maps over the slice names and extracts the state type for each slice. The resulting type represents the complete state structure of your Redux store.
+
+## Example
+
+
+```typescript
+const slices = [userSlice, cartSlice];
+type RootState = RootStateFromSlices<typeof slices>;
+// Result: { user: UserState, cart: CartState }
+```
+

package/docs/api/foundation-redux.selectorsfromslices.md

@@ -0,0 +1,40 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md) &gt; [SelectorsFromSlices](./foundation-redux.selectorsfromslices.md)
+
+## SelectorsFromSlices type
+
+Extracts the bound selectors type from an array of slices.
+
+**Signature:**
+
+```typescript
+export type SelectorsFromSlices<S extends SliceArray> = {
+    [K in S[number]['name']]: {
+        [SelectorKey in keyof Extract<S[number], {
+            name: K;
+        }>['selectors']]: (...payload: RemoveFirstParameter<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]>) => ReturnType<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]> extends void ? any : ReturnType<Extract<S[number], {
+            name: K;
+        }>['selectors'][SelectorKey]>;
+    };
+};
+```
+**References:** [SliceArray](./foundation-redux.slicearray.md)
+
+## Remarks
+
+This utility type creates a nested object structure where each slice name maps to its selectors. Selectors are bound to the store and can access the current state.
+
+## Example
+
+
+```typescript
+const { selectors } = createStore([userSlice, cartSlice], initialState);
+// const userName = selectors.user.getUserName()
+// const cartTotal = selectors.cart.getTotal()
+```
+

package/docs/api/foundation-redux.slice.actions.md

@@ -0,0 +1,13 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@genesislcap/foundation-redux](./foundation-redux.md) &gt; [Slice](./foundation-redux.slice.md) &gt; [actions](./foundation-redux.slice.actions.md)
+
+## Slice.actions property
+
+Action creators for this slice
+
+**Signature:**
+
+```typescript
+actions: Record<string, (payload: any) => Action>;
+```