eze-factory 1.0.0

package/README.md

@@ -0,0 +1,59 @@
+# Eze-Factory
+
+**A revolutionary architecture for building React applications through composable state and modular logic.**
+
+## Documentation
+
+📖 **[Complete Documentation](./Eze-Factory-Docs.md)** — Everything about Eze-Factory's philosophy, patterns, and usage.
+
+## Quick Start
+
+```bash
+npm install eze-factory
+```
+
+### Basic State (Hive)
+
+```typescript
+import { createHive } from "eze-factory";
+
+const counter = createHive(0);
+counter.setHoney(1);
+counter.subscribe((value) => console.log(value));
+```
+
+### React Connection (Bee)
+
+```tsx
+import { Bee } from "eze-factory";
+
+<Bee hive={counter} Component={({ honey, setHoney }) => <button onClick={() => setHoney(honey + 1)}>Count: {honey}</button>} />;
+```
+
+### Factory Composition
+
+```typescript
+import { createTableFactory } from 'eze-factory';
+
+// Compose slices into a complete feature
+const UsersFactory = createTableFactory({
+  paginator: { paginator: UsersAPI },
+  table: { columns: () => [...] }
+}).build();
+
+// Use directly — no useState needed!
+UsersFactory.paginator.load();
+UsersFactory.table.toggleColumnVisibility('email');
+UsersFactory.exporter.download({ type: 'csv' });
+```
+
+## Philosophy
+
+- **🐝 Hives** — State lives outside React, accessible anywhere
+- **🔌 Slices** — Reusable logic modules that auto-wire together
+- **🏭 Factories** — Compose slices into complete features
+- **📦 Components** — StatusGuard, StatusIndicator filter by operation
+
+## License
+
+MIT

package/dist/Bees/ArrayBee.d.ts

@@ -0,0 +1,2 @@
+import { ArrayBeeProps } from "./Types";
+export default function ArrayBee<HiveType = any>({ hive, Component }: ArrayBeeProps<HiveType>): any;

package/dist/Bees/Bee.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { BeeProps } from "./Types";
+export default function Bee<HiveType = any>({ hive, Component }: BeeProps<HiveType>): React.JSX.Element;

package/dist/Bees/Bees.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { BeesProps } from "./Types";
+export default function Bees({ hiveCluster, Component }: BeesProps): React.JSX.Element;

package/dist/Bees/FormBee.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { FormBeeProps } from "./Types";
+export default function FormBee<HiveType = any>({ hive, Component }: FormBeeProps<HiveType>): React.JSX.Element;

package/dist/Bees/FormBees.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { FormBeesProps } from "./Types";
+export default function FormBees<HiveType = any>({ hiveCluster, Component }: FormBeesProps<HiveType>): React.JSX.Element;

package/dist/Bees/ObserverBee.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { ObserverBeeProps } from "./Types";
+export default function ObserverBee<HiveType = any>({ hive, Component }: ObserverBeeProps<HiveType>): React.JSX.Element;

package/dist/Bees/ObserverBees.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { ObserverBeesProps } from "./Types";
+export default function ObserverBees({ hiveCluster, Component }: ObserverBeesProps): React.JSX.Element;

package/dist/Bees/ObserverFormBee.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { ObserverFormBeeProps } from "./Types";
+export default function ObserverFormBee<HiveType = any>({ hive, Component }: ObserverFormBeeProps<HiveType>): React.JSX.Element;

package/dist/Bees/ProxyBee.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { IProxyHive } from "../Hives/Types";
+interface ControllerElementProps<T> {
+    hive: IProxyHive<T>;
+    id: keyof T;
+    Component: React.ComponentType<{
+        honey: T[keyof T];
+        setHoney: (value: T[keyof T]) => void;
+        silentSetHoney: (value: T[keyof T]) => void;
+    }>;
+}
+export default function ProxyBee<HiveType>({ hive, Component, id }: ControllerElementProps<HiveType>): React.JSX.Element;
+export {};

package/dist/Bees/Types.d.ts

@@ -0,0 +1,74 @@
+import React from "react";
+import { IHive, IHiveArray, IHiveObserver, INestedFormHive } from "../Hives/Types";
+export type KeyValueHive = {
+    [key: string]: IHive<any> | IHiveArray<any>;
+};
+export type KeyValueNestedFormHive = {
+    [key: string]: INestedFormHive<any>;
+};
+export type KeyValueHiveObserver = {
+    [key: string]: IHiveObserver<any> | IHive<any> | INestedFormHive<any> | IHiveArray<any>;
+};
+export type HoneySetter<HiveType> = (prev: HiveType) => void | HiveType;
+export type BeeProps<HiveType> = {
+    hive: IHive<HiveType>;
+    Component: (props: {
+        honey: HiveType;
+        setHoney: HoneySetter<HiveType>;
+        silentSetHoney: HoneySetter<HiveType>;
+    }) => React.ReactNode;
+};
+export type BeesProps = {
+    hiveCluster: KeyValueHive;
+    Component: (props: {
+        cell: KeyValueHive;
+        set: (newValues: KeyValueHive, replace?: boolean) => void;
+    }) => any;
+};
+export type ArrayBeeProps<HiveType> = {
+    hive: IHiveArray<HiveType>;
+    Component: (props: {
+        honey: HiveType;
+        i: number;
+    }) => any;
+};
+export type ObserverBeeProps<HiveType> = {
+    hive: IHiveObserver<HiveType> | IHive<HiveType>;
+    Component: (props: {
+        honey: HiveType;
+    }) => any;
+};
+export type ObserverBeesProps = {
+    hiveCluster: KeyValueHiveObserver;
+    Component: (props: {
+        cell: KeyValueHiveObserver;
+    }) => any;
+};
+export type INestedFormHoneySetter<K> = (prev: K, effect?: boolean) => void | ((hive: K, effect?: boolean) => void);
+export type FormBeeProps<HiveType> = {
+    hive: INestedFormHive<HiveType>;
+    Component: (props: {
+        honey: HiveType;
+        setHoney: HoneySetter<HiveType>;
+        silentSetHoney: HoneySetter<HiveType>;
+        error?: string;
+        validate: INestedFormHoneySetter<HiveType>;
+    }) => any;
+};
+export type ObserverFormBeeProps<HiveType> = {
+    hive: INestedFormHive<HiveType>;
+    Component: (props: {
+        honey: HiveType;
+        error?: string;
+    }) => any;
+};
+export type FormBeesProps<HiveType> = {
+    hiveCluster: KeyValueNestedFormHive;
+    Component: (props: {
+        cell: KeyValueNestedFormHive;
+        set: (newValues: KeyValueNestedFormHive, replace?: boolean) => void;
+        error?: string;
+        validate: INestedFormHoneySetter<HiveType>;
+    }) => any;
+};
+export type ProxyHoneySetter<K> = (prev: K, effect?: boolean) => void | ((hive: K, effect?: boolean) => void);

package/dist/Bees/index.d.ts

@@ -0,0 +1,10 @@
+export { default as Bee } from "./Bee";
+export { default as Bees } from "./Bees";
+export { default as ArrayBee } from "./ArrayBee";
+export { default as ObserverBee } from "./ObserverBee";
+export { default as ObserverBees } from "./ObserverBees";
+export { default as FormBee } from "./FormBee";
+export { default as FormBees } from "./FormBees";
+export { default as ObserverFormBee } from "./ObserverFormBee";
+export { default as ProxyBee } from "./ProxyBee";
+export * from "./Types";

package/dist/Factory/factory.d.ts

@@ -0,0 +1,9 @@
+import { SliceFactory } from "./types";
+export declare function createFactory(): FactoryBuilder<{}>;
+declare class FactoryBuilder<Ctx> {
+    private ctx;
+    constructor(ctx: Ctx);
+    use<Add>(factory: SliceFactory<Ctx, Add>): FactoryBuilder<Ctx & Add>;
+    build(): Ctx;
+}
+export {};

package/dist/Factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./factory.js";

package/dist/Factory/types.d.ts

@@ -0,0 +1,2 @@
+export type SliceConfig<SliceCreator> = SliceCreator extends (config?: infer C) => any ? C : never;
+export type SliceFactory<Ctx, Add> = (ctx: Ctx) => Add;

package/dist/Hives/AsyncHive.d.ts

@@ -0,0 +1,2 @@
+import { IHive, IStoreKey } from "./Types";
+export declare function createAsyncHive<HiveType = any>(initialValue: HiveType, storeKey?: IStoreKey): IHive<HiveType>;

package/dist/Hives/FormHive.d.ts

@@ -0,0 +1,16 @@
+import { FormValidateMode, IFormHive, IFormHiveValidator, IStoreKey } from "./Types";
+export declare function createFormHive<HiveType>({ initialValue, storeKey, validator, getValidator, validateMode, onSubmit, }: {
+    initialValue: HiveType;
+    storeKey?: IStoreKey;
+    validator?: undefined;
+    getValidator?: (formHive: IFormHive<HiveType>) => IFormHiveValidator<HiveType>;
+    validateMode?: FormValidateMode;
+    onSubmit: (honey: HiveType) => void;
+} | {
+    initialValue: HiveType;
+    storeKey?: IStoreKey;
+    validator?: <K extends keyof HiveType>(key: K, value: HiveType[K]) => string | undefined;
+    getValidator?: undefined;
+    validateMode?: FormValidateMode;
+    onSubmit: (honey: HiveType) => void;
+}): IFormHive<HiveType>;

package/dist/Hives/Hive.d.ts

@@ -0,0 +1,2 @@
+import { IHive, IStoreKey } from "./Types";
+export declare function createHive<HiveType = any>(initialValue: HiveType, storeKey?: IStoreKey): IHive<HiveType>;

package/dist/Hives/HiveArray.d.ts

@@ -0,0 +1,2 @@
+import { IHiveArray, IStoreKey } from "./Types";
+export declare function createHiveArray<HiveType>(initialValue: HiveType[], storeKey?: IStoreKey): IHiveArray<HiveType>;

package/dist/Hives/HiveBase.d.ts

@@ -0,0 +1,2 @@
+import { IHiveBase, IStoreKey } from "./Types";
+export declare function _getHiveBase<HiveType>(initialValue: HiveType, storeKey?: IStoreKey): IHiveBase<HiveType>;

package/dist/Hives/HiveObserver.d.ts

@@ -0,0 +1,3 @@
+import { HiveGetter } from "./Types";
+import { IHiveObserver } from "./Types";
+export declare function createHiveObserver<HiveType>(listen: HiveGetter<HiveType>): IHiveObserver<HiveType>;

package/dist/Hives/HiveUtils.d.ts

@@ -0,0 +1,3 @@
+import { StorageType } from "../Utils/Storable";
+export declare const getStorable: (storage?: StorageType) => any;
+export declare const CheckSimilarity: (a: any, b: any) => boolean;

package/dist/Hives/ProxyHive.d.ts

@@ -0,0 +1,2 @@
+import { IProxyHive, IStoreKey } from "./Types";
+export declare function createProxyHive<HiveType>(initialValue: HiveType, storeKey?: IStoreKey): IProxyHive<HiveType>;

package/dist/Hives/Types.d.ts

@@ -0,0 +1,98 @@
+import { StorageType } from "../Utils/Storable";
+export interface IHive<HiveType> {
+    honey: HiveType;
+    setHoney: (newValue: HiveType | ((prev: HiveType) => HiveType)) => void;
+    silentSetHoney: (newValue: HiveType | ((prev: HiveType) => HiveType)) => void;
+    subscribe: (callback: (newValue: HiveType) => void) => () => void;
+    _subscribers: () => number;
+    reset: () => void;
+    clearStore?: () => void;
+    initialValue: HiveType;
+}
+export type HiveGetter<HiveType> = (get: <Target>(a: IHive<Target>) => Target) => HiveType;
+export type IHiveBase<HiveType> = [IHive<HiveType>, () => void];
+export interface IHiveObserver<HiveType> {
+    honey: any;
+    subscribe: (callback: (newValue: HiveType) => void) => () => void;
+    _subscribers: () => number;
+    setHoney?: undefined;
+    silentSetHoney?: undefined;
+}
+export interface IHiveArray<HiveType> {
+    honey: HiveType[];
+    setHoney: (newValue: HiveType[] | ((prev: HiveType[]) => HiveType[])) => void;
+    silentSetHoney: (newValue: HiveType[]) => void;
+    subscribe: (callback: (newValue: HiveType[]) => void) => () => void;
+    _subscribers: () => number;
+    push: (newValue: HiveType) => void;
+    pop: () => void;
+    shift: () => void;
+    unshift: (newValue: HiveType) => void;
+    splice: (start: number, deleteCount: number, ...items: HiveType[]) => void;
+    remove: (id: any) => void;
+    removeById: (id: any) => void;
+    removeByIndex: (index: number) => void;
+    append: (items: HiveType[]) => void;
+    update: () => void;
+    updateById: (id: any, newValue: HiveType) => void;
+    updateByIndex: (index: number, newValue: HiveType) => void;
+}
+export interface IProxyHive<HiveType> extends IHive<HiveType> {
+    createNestedHive: <NestedHiveType>(key: string, initialValue: NestedHiveType, storeKey?: string) => IHive<NestedHiveType>;
+    getNestedHive: <K extends keyof HiveType>(key: K) => IHive<HiveType[K]> | undefined;
+    setNestedHoney: <K extends keyof HiveType>(key: K, value: HiveType[K] | ((prev: HiveType[K]) => HiveType[K]), effect?: boolean) => void;
+    getNestedHoney: <K extends keyof HiveType>(key: K) => HiveType[K];
+    subscribeToNestedHive: <K extends keyof HiveType>(key: K, callback: (value: HiveType[K]) => void) => void;
+    reset: () => void;
+}
+export interface IFormHive<HiveType> extends IHive<HiveType> {
+    createNestedHive: <NestedHiveType>(key: string, initialValue: NestedHiveType, storeKey?: string) => INestedFormHive<NestedHiveType>;
+    getNestedHive: <K extends keyof HiveType>(key: K) => INestedFormHive<HiveType[K]>;
+    setNestedHoney: <K extends keyof HiveType>(key: K, value: HiveType[K] | ((prev: HiveType[K]) => HiveType[K]), effect?: boolean) => void;
+    getNestedHoney: <K extends keyof HiveType>(key: K) => HiveType[K];
+    subscribeToNestedHive: <K extends keyof HiveType>(key: K, callback: (value: HiveType[K]) => void) => void;
+    validate: <K extends keyof HiveType>(key: K, value: HiveType[K], effect?: boolean) => void;
+    errors: {
+        [key: string]: string;
+    };
+    getError: (key: keyof HiveType) => string;
+    setError: (key: keyof HiveType, value: string) => void;
+    clearErrors: () => void;
+    isDirtyHive: IHive<boolean>;
+    isValidHive: IHive<boolean>;
+    reValidate: <K extends keyof HiveType>(validateKeys?: K[]) => Promise<boolean>;
+    submit: <K extends keyof HiveType>(e?: React.FormEvent<HTMLFormElement>, validateKeys?: K[]) => void;
+    validateMode: FormValidateMode;
+    reset: (initialValue?: {
+        key: keyof HiveType;
+        value: HiveType[keyof HiveType];
+    }) => void;
+}
+export interface INestedFormHive<HiveType> {
+    initialValue: HiveType;
+    setHoney: (newValue: HiveType | ((prev: HiveType) => HiveType)) => void;
+    silentSetHoney: (newValue: HiveType | ((prev: HiveType) => HiveType)) => void;
+    subscribe: (callback: (newValue: {
+        value: HiveType;
+        error?: string;
+    }) => void) => () => void;
+    _subscribers: () => number;
+    clearStore?: () => void;
+    honey: {
+        value: HiveType;
+        error?: string;
+    };
+    error?: string;
+    setError: (err?: string) => void;
+    validate: (honey: HiveType, effect?: boolean) => void;
+    isValid: () => boolean | Promise<boolean>;
+    reset: () => void;
+}
+export type IStoreKey = string | {
+    storeKey: string;
+    storage: StorageType;
+};
+export type FormValidateMode = "onBlur" | "onChange" | "onSubmit";
+export type IFormHiveValidator<T> = {
+    [K in keyof T]?: (value: T[K]) => string | undefined;
+};

package/dist/Hives/index.d.ts

@@ -0,0 +1,6 @@
+export { createHive } from "./Hive";
+export { createHiveArray } from "./HiveArray";
+export { createHiveObserver } from "./HiveObserver";
+export { createProxyHive } from "./ProxyHive";
+export { createFormHive } from "./FormHive";
+export * from "./Types";

package/dist/Hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { default as useHoney } from "./useHoney";
+export { default as useHive } from "./useHive";
+export { default as useFormHive } from "./useFormHive";
+export { default as useFormHoney } from "./useFormHoney";

package/dist/Hooks/useFormHive.d.ts

@@ -0,0 +1,5 @@
+import { INestedFormHive } from "../Hives/Types";
+export default function useFormHive<HiveType>(hive: INestedFormHive<HiveType>): [{
+    value: HiveType;
+    error?: string;
+}, (honey: HiveType, effect?: boolean) => void];

package/dist/Hooks/useFormHoney.d.ts

@@ -0,0 +1,5 @@
+import { INestedFormHive } from "../Hives/Types";
+export default function useFormHoney<HiveType>(hive: INestedFormHive<HiveType>): {
+    value: HiveType;
+    error?: string;
+};

package/dist/Hooks/useHive.d.ts

@@ -0,0 +1,2 @@
+import { IHive } from "../Hives/Types";
+export default function useHive<HiveType>(hive: IHive<HiveType>): any[];

package/dist/Hooks/useHoney.d.ts

@@ -0,0 +1,2 @@
+import { IHive, IHiveArray, IHiveObserver, INestedFormHive } from "../Hives/Types";
+export default function useHoney<HiveType>(hive: IHive<HiveType> | IHiveObserver<HiveType> | IHiveArray<HiveType> | INestedFormHive<HiveType>): any;

package/dist/System/Constants/Kit/Error.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Error: () => React.JSX.Element;
+export default Error;

package/dist/System/Constants/Kit/IosLoader.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const IosLoader: () => React.JSX.Element;
+export default IosLoader;

package/dist/System/Constants/Kit/ItemsLoading.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const ItemsLoading: ({}: {}) => React.JSX.Element;
+export default ItemsLoading;

package/dist/System/Constants/Kit/Loader.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type Props = {
+    variant?: "v-small" | "small" | "medium" | "large";
+};
+declare const Loader: ({ variant }: Props) => React.JSX.Element;
+export default Loader;

package/dist/System/Constants/Kit/LoaderTwo.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+type Props = {
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare const LoaderTwo: ({ className, style }: Props) => React.JSX.Element;
+export default LoaderTwo;

package/dist/System/Constants/Kit/Loading.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Loading: () => React.JSX.Element;
+export default Loading;

package/dist/System/Constants/Kit/NoContent.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export interface Props {
+    label: string;
+}
+declare const _default: React.MemoExoticComponent<({ label }: Props) => React.JSX.Element>;
+export default _default;

package/dist/System/Constants/Kit/Progressing.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export interface Props {
+    label?: string;
+    service?: any;
+}
+declare const Progressing: ({ label }: Props) => React.JSX.Element;
+export default Progressing;

package/dist/System/Constants/Kit/Searching.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Searching: () => React.JSX.Element;
+export default Searching;

package/dist/System/Constants/Kit/StateKit.d.ts

@@ -0,0 +1,21 @@
+declare const StateKit: {
+    error: () => import("react").JSX.Element;
+    processing: ({ label }: import("./Progressing").Props) => import("react").JSX.Element;
+    loading: () => import("react").JSX.Element;
+    noContent: import("react").MemoExoticComponent<({ label }: import("./NoContent").Props) => import("react").JSX.Element>;
+    empty: import("react").MemoExoticComponent<({ label }: import("./NoContent").Props) => import("react").JSX.Element>;
+    reloading: () => import("react").JSX.Element;
+};
+export default StateKit;
+export type IState = "idle" | "loading" | "processing" | "reloading" | "searching" | "error" | "noContent" | "loadingMore";
+export type ServiceState = IState | {
+    state: IState;
+    props: any;
+    parent?: HTMLElement | undefined;
+} | {
+    state: "noContent";
+    props: {
+        label: string;
+    };
+    parent?: HTMLElement | undefined;
+};

package/dist/System/Constants/Kit/index.d.ts

@@ -0,0 +1,4 @@
+import "./stateKit.css";
+export * from "./StateKit";
+export { default as StateKit } from "./StateKit";
+export { default as Loader } from "./Loader";

package/dist/System/Constants/QueryDefaults.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export declare const DefaultComponentMap: {
+    readonly text: any;
+    readonly number: any;
+    readonly boolean: any;
+    readonly selector: any;
+    readonly "multi-selector": any;
+    readonly "string-selector": any;
+    readonly "number-selector": any;
+    readonly "selector-api": any;
+    readonly Date: any;
+    readonly Time: any;
+    readonly DateTime: (props: any) => React.JSX.Element;
+    readonly Float: any;
+    readonly Int32: any;
+    readonly hidden: () => React.JSX.Element;
+};

package/dist/System/Constants/StatusDefaults.d.ts

@@ -0,0 +1,8 @@
+export declare const DefaultStatusKit: {
+    error: () => import("react").JSX.Element;
+    processing: ({ label }: import("./Kit/Progressing").Props) => import("react").JSX.Element;
+    loading: () => import("react").JSX.Element;
+    noContent: import("react").MemoExoticComponent<({ label }: import("./Kit/NoContent").Props) => import("react").JSX.Element>;
+    empty: import("react").MemoExoticComponent<({ label }: import("./Kit/NoContent").Props) => import("react").JSX.Element>;
+    reloading: () => import("react").JSX.Element;
+};

package/dist/System/Factories/DetailFactory.d.ts

@@ -0,0 +1,25 @@
+import { FilterDefinition, QueryComponentMap } from "../Slices/Query/Types";
+import { StatusSliceConfig } from "../Slices/Status/Types";
+import { LoaderFunction, LoaderProps } from "../Slices/Loader/Types";
+import { DefaultComponentMap } from "../Constants/QueryDefaults";
+type DefaultMap = typeof DefaultComponentMap;
+type MergedMap<M extends QueryComponentMap> = DefaultMap & M;
+type FactoryQueryConfig<M extends QueryComponentMap> = {
+    componentMap?: M;
+    filters: Record<string, FilterDefinition<MergedMap<M>>>;
+    validators?: any[];
+    onQueryChange?: (query: any) => void;
+    syncWithRouter?: boolean;
+};
+export declare function createDetailFactory<L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined, M extends QueryComponentMap = {}>(config: {
+    query?: FactoryQueryConfig<M>;
+    loader: LoaderProps<L, R, Fmt>;
+    status?: Partial<StatusSliceConfig>;
+}): import("./FactoryPackage").Factory<{
+    status: import("../Slices/Status/Types").StatusAPI<import("../Slices/Status/Types").StatusKit>;
+} & {
+    query: import("../Slices/Query/Types").QueryAPI<MergedMap<M>, Record<string, FilterDefinition<MergedMap<M>>>>;
+} & {
+    loader: import("../Slices/Loader/Types").LoaderAPI<Fmt extends undefined ? R : Fmt>;
+}>;
+export {};

package/dist/System/Factories/FactoryPackage.d.ts

@@ -0,0 +1,6 @@
+export type Slice<T = any, Ctx = any> = (ctx: Ctx) => T;
+export type Factory<Ctx = {}> = {
+    use: <S extends Slice<any, Ctx>>(slice: S) => Factory<Ctx & ReturnType<S>>;
+    build: () => Ctx;
+};
+export declare function createFactory<Ctx = {}>(): Factory<Ctx>;

package/dist/System/Factories/ListFactory.d.ts

@@ -0,0 +1,34 @@
+import { FilterDefinition, QueryComponentMap } from "../Slices/Query/Types";
+import { StatusSliceConfig } from "../Slices/Status/Types";
+import { PaginatorProps } from "../Slices/Paginator/Types";
+import { DefaultComponentMap } from "../Constants/QueryDefaults";
+import { DefaultStatusKit } from "../Constants/StatusDefaults";
+type DefaultMap = typeof DefaultComponentMap;
+type MergedMap<M extends QueryComponentMap> = DefaultMap & M;
+type DefaultStatusMap = typeof DefaultStatusKit;
+export declare function createListFactory<P extends {
+    load: (...args: any[]) => Promise<any>;
+    reload: (...args: any[]) => Promise<any>;
+    loadMore: () => Promise<any>;
+    hasMore: boolean;
+    limit: number;
+}, R = Awaited<ReturnType<P["load"]>>, Fmt = undefined, M extends QueryComponentMap = {}, F extends Record<string, FilterDefinition<MergedMap<M>>> = Record<string, FilterDefinition<MergedMap<M>>>, SK extends Record<string, any> = {}>(config: {
+    query?: {
+        componentMap?: M;
+        filters: F;
+        validators?: any[];
+        onQueryChange?: (query: any) => void;
+        syncWithRouter?: boolean;
+    };
+    paginator: PaginatorProps<P, R, Fmt, any>;
+    status?: Omit<Partial<StatusSliceConfig<DefaultStatusMap & SK>>, "statusKit"> & {
+        statusKit?: SK;
+    };
+}): import("./FactoryPackage").Factory<{
+    status: import("../Slices/Status/Types").StatusAPI<import("../Slices/Status/Types").StatusKit>;
+} & {
+    query: import("../Slices/Query/Types").QueryAPI<MergedMap<M>, F>;
+} & {
+    paginator: import("../Slices/Paginator/Types").PaginatorAPI<import("../Slices/Paginator/PaginatorMechanics").ArrayElement<Fmt extends undefined ? R : Fmt>, any>;
+}>;
+export {};

package/dist/System/Factories/StaticTableFactory.d.ts

@@ -0,0 +1,33 @@
+import { FilterDefinition, QueryComponentMap } from "../Slices/Query/Types";
+import { StatusSliceConfig } from "../Slices/Status/Types";
+import { LoaderFunction, LoaderProps } from "../Slices/Loader/Types";
+import { TableSliceConfig } from "../Slices/Table/Types";
+import { ExporterSliceConfig } from "../Slices/Exporter/Types";
+import { DefaultComponentMap } from "../Constants/QueryDefaults";
+type DefaultMap = typeof DefaultComponentMap;
+type MergedMap<M extends QueryComponentMap> = DefaultMap & M;
+type FactoryQueryConfig<M extends QueryComponentMap> = {
+    componentMap?: M;
+    filters: Record<string, FilterDefinition<MergedMap<M>>>;
+    validators?: any[];
+    onQueryChange?: (query: any) => void;
+    syncWithRouter?: boolean;
+};
+export declare function createStaticTableFactory<L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined, M extends QueryComponentMap = {}>(config: {
+    query?: FactoryQueryConfig<M>;
+    loader: LoaderProps<L, R, Fmt>;
+    status?: Partial<StatusSliceConfig>;
+    table: TableSliceConfig<Fmt extends undefined ? (R extends any[] ? R[number] : never) : (Fmt extends any[] ? Fmt[number] : never)>;
+    exporter?: ExporterSliceConfig<Fmt extends undefined ? (R extends any[] ? R[number] : never) : (Fmt extends any[] ? Fmt[number] : never)>;
+}): import("./FactoryPackage").Factory<{
+    status: import("../Slices/Status/Types").StatusAPI<import("../Slices/Status/Types").StatusKit>;
+} & {
+    query: import("../Slices/Query/Types").QueryAPI<MergedMap<M>, Record<string, FilterDefinition<MergedMap<M>>>>;
+} & {
+    loader: import("../Slices/Loader/Types").LoaderAPI<Fmt extends undefined ? R : Fmt>;
+} & {
+    table: import("../Slices/Table/Types").TableAPI<Fmt extends undefined ? R extends any[] ? R[number] : never : Fmt extends any[] ? Fmt[number] : never>;
+} & {
+    exporter: import("../Slices/Exporter/Types").ExporterAPI;
+}>;
+export {};