@lumeweb/portal-framework-ui 0.0.1 → 0.1.1

package/dist/esm/components/shared/registry/FooterRegistry.js

@@ -0,0 +1,47 @@
+import { DialogTypes } from "../../dialog/Dialog.types.js";
+import { ContainerType } from "../types/container.js";
+import { FormType } from "../types/form.js";
+import { ActionsFooter } from "../footers/ActionsFooter.js";
+import { DefaultFooter } from "../footers/DefaultFooter.js";
+import { FormFooter } from "../footers/FormFooter.js";
+import { StepFormFooter } from "../footers/StepFormFooter.js";
+import { WizardFooter } from "../footers/WizardFooter.js";
+import { FooterType } from "./types.js";
+import "../../index.js";
+
+//#region src/components/shared/registry/FooterRegistry.ts
+function createFooterRegistry() {
+	const components = /* @__PURE__ */ new Map();
+	components.set("default", DefaultFooter);
+	components.set("form", FormFooter);
+	components.set("step_form", StepFormFooter);
+	components.set("wizard_form", WizardFooter);
+	components.set("actions", ActionsFooter);
+	return {
+		get(type) {
+			const component = components.get(type);
+			if (!component) {
+				console.warn(`Footer component not found for type: ${type}, falling back to DEFAULT`);
+				return components.get("default");
+			}
+			return component;
+		},
+		register(type, component) {
+			components.set(type, component);
+		},
+		resolveType(config, context) {
+			if (context.container.type === "dialog" && config.type === DialogTypes.FORM && "actions" in config && config.actions) return "actions";
+			switch (context.form?.type) {
+				case "wizard": return "wizard_form";
+				case "step": return "step_form";
+				case "simple":
+				default: return "default";
+			}
+		}
+	};
+}
+const footerRegistry = createFooterRegistry();
+
+//#endregion
+export { createFooterRegistry, footerRegistry };
+//# sourceMappingURL=FooterRegistry.js.map

package/dist/esm/components/shared/registry/FooterRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FooterRegistry.js","names":[],"sources":["../../../../../src/components/shared/registry/FooterRegistry.ts"],"sourcesContent":["import { BaseRecord } from \"@refinedev/core\";\n\nimport {\n  ActionsFooter,\n  ContainerType,\n  DefaultFooter,\n  DialogType,\n  DialogTypes,\n  FooterEnvironment,\n  FormFooter,\n  FormType,\n  StepFormFooter,\n  WizardFooter,\n} from \"@/components\";\nimport { FooterComponent, FooterType } from \"./types\";\n\nexport interface FooterRegistry {\n  get: (type: FooterType) => FooterComponent;\n  register: (type: FooterType, component: FooterComponent) => void;\n  resolveType: <T extends BaseRecord>(\n    config: any,\n    context: FooterEnvironment<T>,\n  ) => FooterType;\n}\n\nexport function createFooterRegistry(): FooterRegistry {\n  const components = new Map<FooterType, FooterComponent>();\n\n  // Register default components\n\n  components.set(FooterType.DEFAULT, DefaultFooter);\n  components.set(FooterType.FORM, FormFooter);\n  components.set(FooterType.STEP_FORM, StepFormFooter);\n  components.set(FooterType.WIZARD_FORM, WizardFooter);\n  components.set(FooterType.ACTIONS, ActionsFooter);\n\n  return {\n    get(type: FooterType): FooterComponent {\n      const component = components.get(type);\n      if (!component) {\n        console.warn(\n          `Footer component not found for type: ${type}, falling back to DEFAULT`,\n        );\n        return components.get(FooterType.DEFAULT)!;\n      }\n      return component;\n    },\n\n    register(type: FooterType, component: FooterComponent): void {\n      components.set(type, component);\n    },\n\n    resolveType<T extends BaseRecord>(\n      config: any,\n      context: FooterEnvironment<T>,\n    ): FooterType {\n      // Priority 2: Actions dropdown (dialog-specific)\n      if (\n        context.container.type === ContainerType.DIALOG &&\n        config.type === DialogTypes.FORM &&\n        \"actions\" in config &&\n        config.actions\n      ) {\n        return FooterType.ACTIONS;\n      }\n\n      // Priority 3: Form type based on context\n      switch (context.form?.type) {\n        case FormType.WIZARD:\n          return FooterType.WIZARD_FORM;\n        case FormType.STEP:\n          return FooterType.STEP_FORM;\n        case FormType.SIMPLE:\n        default:\n          return FooterType.DEFAULT;\n      }\n    },\n  };\n}\n\n// Create singleton instance\nexport const footerRegistry = createFooterRegistry();\n"],"mappings":";;;;;;;;;;;;AAyBA,SAAgB,uBAAuC;CACrD,MAAM,6BAAa,IAAI,KAAkC;AAIzD,YAAW,eAAwB,cAAc;AACjD,YAAW,YAAqB,WAAW;AAC3C,YAAW,iBAA0B,eAAe;AACpD,YAAW,mBAA4B,aAAa;AACpD,YAAW,eAAwB,cAAc;AAEjD,QAAO;EACL,IAAI,MAAmC;GACrC,MAAM,YAAY,WAAW,IAAI,KAAK;AACtC,OAAI,CAAC,WAAW;AACd,YAAQ,KACN,wCAAwC,KAAK,2BAC9C;AACD,WAAO,WAAW,cAAuB;;AAE3C,UAAO;;EAGT,SAAS,MAAkB,WAAkC;AAC3D,cAAW,IAAI,MAAM,UAAU;;EAGjC,YACE,QACA,SACY;AAEZ,OACE,QAAQ,UAAU,qBAClB,OAAO,SAAS,YAAY,QAC5B,aAAa,UACb,OAAO,QAEP;AAIF,WAAQ,QAAQ,MAAM,MAAtB;IACE,cACE;IACF,YACE;IACF;IACA,QACE;;;EAGP;;AAIH,MAAa,iBAAiB,sBAAsB"}

package/dist/esm/components/shared/registry/HeaderRegistry.d.ts

@@ -0,0 +1,15 @@
+import { HeaderEnvironment } from "../types/header.js";
+import { HeaderComponent, HeaderType } from "./types.js";
+import { BaseRecord } from "@refinedev/core";
+
+//#region src/components/shared/registry/HeaderRegistry.d.ts
+interface HeaderRegistry {
+  get: (type: HeaderType | null) => HeaderComponent | null;
+  register: (type: HeaderType, component: HeaderComponent) => void;
+  resolveType: <T extends BaseRecord>(config: any, context: HeaderEnvironment<T>) => HeaderType | null;
+}
+declare function createHeaderRegistry(): HeaderRegistry;
+declare const headerRegistry: HeaderRegistry;
+//#endregion
+export { HeaderRegistry, createHeaderRegistry, headerRegistry };
+//# sourceMappingURL=HeaderRegistry.d.ts.map

package/dist/esm/components/shared/registry/HeaderRegistry.js

@@ -0,0 +1,41 @@
+import { NavigationType } from "../types/header.js";
+import { DefaultHeader } from "../headers/DefaultHeader.js";
+import { FormHeader } from "../headers/FormHeader.js";
+import { WizardHeader } from "../headers/WizardHeader.js";
+import { HeaderType } from "./types.js";
+
+//#region src/components/shared/registry/HeaderRegistry.ts
+function createHeaderRegistry() {
+	const components = /* @__PURE__ */ new Map();
+	components.set("default", DefaultHeader);
+	components.set("form", FormHeader);
+	components.set("wizard", WizardHeader);
+	return {
+		get(type) {
+			if (type === null) return null;
+			const component = components.get(type);
+			if (!component) {
+				console.warn(`Header component not found for type: ${type}, falling back to DEFAULT`);
+				return components.get("default");
+			}
+			return component;
+		},
+		register(type, component) {
+			components.set(type, component);
+		},
+		resolveType(config, context) {
+			if ("header" in config && config.header === false) return "custom";
+			switch (context.navigation.type) {
+				case "wizard": return "wizard";
+				case "none": return null;
+				case "step":
+				default: return "form";
+			}
+		}
+	};
+}
+const headerRegistry = createHeaderRegistry();
+
+//#endregion
+export { createHeaderRegistry, headerRegistry };
+//# sourceMappingURL=HeaderRegistry.js.map

package/dist/esm/components/shared/registry/HeaderRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeaderRegistry.js","names":[],"sources":["../../../../../src/components/shared/registry/HeaderRegistry.ts"],"sourcesContent":["import { BaseRecord } from \"@refinedev/core\";\n\nimport { DefaultHeader } from \"../headers/DefaultHeader\";\nimport { FormHeader } from \"../headers/FormHeader\";\nimport { WizardHeader } from \"../headers/WizardHeader\";\nimport { HeaderEnvironment, NavigationType } from \"../types/header\";\nimport { HeaderComponent, HeaderType } from \"./types\";\n\nexport interface HeaderRegistry {\n  get: (type: HeaderType | null) => HeaderComponent | null;\n  register: (type: HeaderType, component: HeaderComponent) => void;\n  resolveType: <T extends BaseRecord>(\n    config: any,\n    context: HeaderEnvironment<T>,\n  ) => HeaderType | null;\n}\n\nexport function createHeaderRegistry(): HeaderRegistry {\n  const components = new Map<HeaderType, HeaderComponent>();\n\n  // Register default components\n\n  components.set(HeaderType.DEFAULT, DefaultHeader);\n  components.set(HeaderType.FORM, FormHeader);\n  components.set(HeaderType.WIZARD, WizardHeader);\n\n  return {\n    get(type: HeaderType | null): HeaderComponent | null {\n      if (type === null) {\n        return null;\n      }\n      \n      const component = components.get(type);\n      if (!component) {\n        console.warn(\n          `Header component not found for type: ${type}, falling back to DEFAULT`,\n        );\n        return components.get(HeaderType.DEFAULT)!;\n      }\n      return component;\n    },\n\n    register(type: HeaderType, component: HeaderComponent): void {\n      components.set(type, component);\n    },\n\n    resolveType<T extends BaseRecord>(\n      config: any,\n      context: HeaderEnvironment<T>,\n    ): HeaderType | null {\n      // Priority 1: Explicit header configuration\n      if (\"header\" in config && config.header === false) {\n        return HeaderType.CUSTOM;\n      }\n\n      // Priority 2: Navigation type based on context\n      switch (context.navigation.type) {\n        case NavigationType.WIZARD:\n          return HeaderType.WIZARD;\n        case NavigationType.NONE:\n          return null;\n        case NavigationType.STEP:\n        default:\n          return HeaderType.FORM;\n      }\n    },\n  };\n}\n\n// Create singleton instance\nexport const headerRegistry = createHeaderRegistry();\n"],"mappings":";;;;;;;AAiBA,SAAgB,uBAAuC;CACrD,MAAM,6BAAa,IAAI,KAAkC;AAIzD,YAAW,eAAwB,cAAc;AACjD,YAAW,YAAqB,WAAW;AAC3C,YAAW,cAAuB,aAAa;AAE/C,QAAO;EACL,IAAI,MAAiD;AACnD,OAAI,SAAS,KACX,QAAO;GAGT,MAAM,YAAY,WAAW,IAAI,KAAK;AACtC,OAAI,CAAC,WAAW;AACd,YAAQ,KACN,wCAAwC,KAAK,2BAC9C;AACD,WAAO,WAAW,cAAuB;;AAE3C,UAAO;;EAGT,SAAS,MAAkB,WAAkC;AAC3D,cAAW,IAAI,MAAM,UAAU;;EAGjC,YACE,QACA,SACmB;AAEnB,OAAI,YAAY,UAAU,OAAO,WAAW,MAC1C;AAIF,WAAQ,QAAQ,WAAW,MAA3B;IACE,cACE;IACF,YACE,QAAO;IACT;IACA,QACE;;;EAGP;;AAIH,MAAa,iBAAiB,sBAAsB"}

package/dist/esm/components/shared/registry/index.d.ts

@@ -0,0 +1,4 @@
+import { FooterComponent, FooterType, HeaderComponent, HeaderType } from "./types.js";
+import { FooterRegistry, createFooterRegistry, footerRegistry } from "./FooterRegistry.js";
+import { HeaderRegistry, createHeaderRegistry, headerRegistry } from "./HeaderRegistry.js";
+export { FooterComponent, FooterRegistry, FooterType, HeaderComponent, HeaderRegistry, HeaderType, createFooterRegistry, createHeaderRegistry, footerRegistry, headerRegistry };

package/dist/esm/components/shared/registry/index.js

@@ -0,0 +1,5 @@
+import { FooterType, HeaderType } from "./types.js";
+import { createFooterRegistry, footerRegistry } from "./FooterRegistry.js";
+import { createHeaderRegistry, headerRegistry } from "./HeaderRegistry.js";
+
+export { FooterType, HeaderType, createFooterRegistry, createHeaderRegistry, footerRegistry, headerRegistry };

package/dist/esm/components/shared/registry/types.d.ts

@@ -0,0 +1,23 @@
+import { BaseFooterProps, FormFooterProps } from "../types/footer.js";
+import { BaseHeaderProps } from "../types/header.js";
+
+//#region src/components/shared/registry/types.d.ts
+declare enum FooterType {
+  ACTIONS = "actions",
+  CUSTOM = "custom",
+  DEFAULT = "default",
+  FORM = "form",
+  WIZARD_FORM = "wizard_form",
+  STEP_FORM = "step_form"
+}
+declare enum HeaderType {
+  CUSTOM = "custom",
+  DEFAULT = "default",
+  FORM = "form",
+  WIZARD = "wizard"
+}
+type FooterComponent<T = any> = React.ComponentType<BaseFooterProps<T> | FormFooterProps<T>>;
+type HeaderComponent<T = any> = React.ComponentType<BaseHeaderProps<T>>;
+//#endregion
+export { FooterComponent, FooterType, HeaderComponent, HeaderType };
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/components/shared/registry/types.js

@@ -0,0 +1,21 @@
+//#region src/components/shared/registry/types.ts
+let FooterType = /* @__PURE__ */ function(FooterType) {
+	FooterType["ACTIONS"] = "actions";
+	FooterType["CUSTOM"] = "custom";
+	FooterType["DEFAULT"] = "default";
+	FooterType["FORM"] = "form";
+	FooterType["WIZARD_FORM"] = "wizard_form";
+	FooterType["STEP_FORM"] = "step_form";
+	return FooterType;
+}({});
+let HeaderType = /* @__PURE__ */ function(HeaderType) {
+	HeaderType["CUSTOM"] = "custom";
+	HeaderType["DEFAULT"] = "default";
+	HeaderType["FORM"] = "form";
+	HeaderType["WIZARD"] = "wizard";
+	return HeaderType;
+}({});
+
+//#endregion
+export { FooterType, HeaderType };
+//# sourceMappingURL=types.js.map

package/dist/esm/components/shared/registry/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/components/shared/registry/types.ts"],"sourcesContent":["import { BaseFooterProps, FormFooterProps } from \"../types/footer\";\nimport { BaseHeaderProps } from \"../types/header\";\n\nexport enum FooterType {\n  ACTIONS = \"actions\",\n  CUSTOM = \"custom\",\n  DEFAULT = \"default\",\n  FORM = \"form\",\n  WIZARD_FORM = \"wizard_form\",\n  STEP_FORM = \"step_form\",\n}\n\nexport enum HeaderType {\n  CUSTOM = \"custom\",\n  DEFAULT = \"default\",\n  FORM = \"form\",\n  WIZARD = \"wizard\",\n}\n\nexport type FooterComponent<T = any> = React.ComponentType<BaseFooterProps<T> | FormFooterProps<T>>;\nexport type HeaderComponent<T = any> = React.ComponentType<BaseHeaderProps<T>>;\n"],"mappings":";AAGA,IAAY,aAAL;AACL;AACA;AACA;AACA;AACA;AACA;;KACD;AAED,IAAY,aAAL;AACL;AACA;AACA;AACA;;KACD"}

package/dist/esm/components/shared/types/container.d.ts

@@ -0,0 +1,70 @@
+import { DialogConfig } from "../../dialog/Dialog.types.js";
+
+//#region src/components/shared/types/container.d.ts
+/**
+ * Enum representing the different types of containers
+ */
+declare enum ContainerType {
+  /**
+   * Dialog container type
+   */
+  DIALOG = "dialog",
+  /**
+   * Standalone container type
+   */
+  STANDALONE = "standalone"
+}
+/**
+ * Union type representing any container environment
+ */
+type AnyContainerEnvironment = DialogContainerEnvironment | StandaloneContainerEnvironment;
+/**
+ * Base interface for container environment
+ */
+interface ContainerEnvironment {
+  /**
+   * The type of container
+   */
+  type: ContainerType;
+}
+/**
+ * Interface representing a dialog container environment
+ */
+interface DialogContainerEnvironment extends ContainerEnvironment {
+  /**
+   * Configuration for the dialog
+   */
+  dialogConfig: DialogConfig<any>;
+  /**
+   * Function to close the dialog
+   */
+  onClose: () => void;
+  /**
+   * The type of container (dialog)
+   */
+  type: ContainerType.DIALOG;
+}
+/**
+ * Interface representing a standalone container environment
+ */
+interface StandaloneContainerEnvironment extends ContainerEnvironment {
+  /**
+   * The type of container (standalone)
+   */
+  type: ContainerType.STANDALONE;
+}
+/**
+ * Type guard to check if a container environment is a dialog container
+ * @param ctx - The container environment to check
+ * @returns True if the container is a dialog container, false otherwise
+ */
+declare function isDialogContainer(ctx: AnyContainerEnvironment): ctx is DialogContainerEnvironment;
+/**
+ * Type guard to check if a container environment is a standalone container
+ * @param ctx - The container environment to check
+ * @returns True if the container is a standalone container, false otherwise
+ */
+declare function isStandaloneContainer(ctx: AnyContainerEnvironment): ctx is StandaloneContainerEnvironment;
+//#endregion
+export { AnyContainerEnvironment, ContainerEnvironment, ContainerType, DialogContainerEnvironment, StandaloneContainerEnvironment, isDialogContainer, isStandaloneContainer };
+//# sourceMappingURL=container.d.ts.map

package/dist/esm/components/shared/types/container.js

@@ -0,0 +1,35 @@
+//#region src/components/shared/types/container.ts
+/**
+* Enum representing the different types of containers
+*/
+let ContainerType = /* @__PURE__ */ function(ContainerType) {
+	/**
+	* Dialog container type
+	*/
+	ContainerType["DIALOG"] = "dialog";
+	/**
+	* Standalone container type
+	*/
+	ContainerType["STANDALONE"] = "standalone";
+	return ContainerType;
+}({});
+/**
+* Type guard to check if a container environment is a dialog container
+* @param ctx - The container environment to check
+* @returns True if the container is a dialog container, false otherwise
+*/
+function isDialogContainer(ctx) {
+	return ctx.type === "dialog";
+}
+/**
+* Type guard to check if a container environment is a standalone container
+* @param ctx - The container environment to check
+* @returns True if the container is a standalone container, false otherwise
+*/
+function isStandaloneContainer(ctx) {
+	return ctx.type === "standalone";
+}
+
+//#endregion
+export { ContainerType, isDialogContainer, isStandaloneContainer };
+//# sourceMappingURL=container.js.map

package/dist/esm/components/shared/types/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","names":[],"sources":["../../../../../src/components/shared/types/container.ts"],"sourcesContent":["import type { DialogConfig } from \"../../dialog/Dialog.types\";\n\n/**\n * Enum representing the different types of containers\n */\nexport enum ContainerType {\n  /**\n   * Dialog container type\n   */\n  DIALOG = \"dialog\",\n  /**\n   * Standalone container type\n   */\n  STANDALONE = \"standalone\",\n}\n\n/**\n * Union type representing any container environment\n */\nexport type AnyContainerEnvironment =\n  | DialogContainerEnvironment\n  | StandaloneContainerEnvironment;\n\n/**\n * Base interface for container environment\n */\nexport interface ContainerEnvironment {\n  /**\n   * The type of container\n   */\n  type: ContainerType;\n}\n\n/**\n * Interface representing a dialog container environment\n */\nexport interface DialogContainerEnvironment extends ContainerEnvironment {\n  /**\n   * Configuration for the dialog\n   */\n  dialogConfig: DialogConfig<any>;\n  /**\n   * Function to close the dialog\n   */\n  onClose: () => void;\n  /**\n   * The type of container (dialog)\n   */\n  type: ContainerType.DIALOG;\n}\n\n/**\n * Interface representing a standalone container environment\n */\nexport interface StandaloneContainerEnvironment extends ContainerEnvironment {\n  /**\n   * The type of container (standalone)\n   */\n  type: ContainerType.STANDALONE;\n}\n\n/**\n * Type guard to check if a container environment is a dialog container\n * @param ctx - The container environment to check\n * @returns True if the container is a dialog container, false otherwise\n */\nexport function isDialogContainer(\n  ctx: AnyContainerEnvironment,\n): ctx is DialogContainerEnvironment {\n  return ctx.type === ContainerType.DIALOG;\n}\n\n/**\n * Type guard to check if a container environment is a standalone container\n * @param ctx - The container environment to check\n * @returns True if the container is a standalone container, false otherwise\n */\nexport function isStandaloneContainer(\n  ctx: AnyContainerEnvironment,\n): ctx is StandaloneContainerEnvironment {\n  return ctx.type === ContainerType.STANDALONE;\n}\n"],"mappings":";;;;AAKA,IAAY,gBAAL;;;;AAIL;;;;AAIA;;KACD;;;;;;AAoDD,SAAgB,kBACd,KACmC;AACnC,QAAO,IAAI;;;;;;;AAQb,SAAgB,sBACd,KACuC;AACvC,QAAO,IAAI"}

package/dist/esm/components/shared/types/environment.d.ts

@@ -0,0 +1,25 @@
+import { DialogContainerEnvironment } from "./container.js";
+import { AnyFormEnvironment } from "./form.js";
+import { StepEnvironment } from "./step.js";
+
+//#region src/components/shared/types/environment.d.ts
+/**
+ * Interface representing a unified environment that combines container, form, and step environments
+ */
+type UnifiedEnvironment = {
+  /**
+   * Optional container environment
+   */
+  container?: DialogContainerEnvironment;
+  /**
+   * Optional form environment
+   */
+  form?: AnyFormEnvironment;
+  /**
+   * Optional step environment
+   */
+  step?: StepEnvironment;
+};
+//#endregion
+export { UnifiedEnvironment };
+//# sourceMappingURL=environment.d.ts.map

package/dist/esm/components/shared/types/footer.d.ts

@@ -0,0 +1,121 @@
+import { ActionItemConfig } from "../../actions/types.js";
+import { AnyContainerEnvironment, DialogContainerEnvironment, StandaloneContainerEnvironment } from "./container.js";
+import { AnyFormEnvironment, SimpleFormEnvironment, StepFormEnvironment, WizardFormEnvironment } from "./form.js";
+import { StepEnvironment } from "./step.js";
+import { BaseRecord } from "@refinedev/core";
+
+//#region src/components/shared/types/footer.d.ts
+/**
+ * Interface representing the base props for a footer component
+ * @template T - The type of record being used
+ */
+interface BaseFooterProps<T extends BaseRecord = any> {
+  /**
+   * Optional array of action button configurations
+   */
+  actionButtons?: ActionItemConfig[];
+  /**
+   * Optional CSS class name
+   */
+  className?: string;
+  /**
+   * The environment configuration for the footer
+   */
+  environment: FooterEnvironment<T>;
+  /**
+   * Whether the form is currently submitting
+   */
+  isSubmitting?: boolean;
+  /**
+   * Function to close the container
+   */
+  onClose?: () => void;
+}
+/**
+ * Interface representing the props for a form footer component
+ * @template T - The type of record being used
+ */
+interface FormFooterProps<T extends BaseRecord = any> extends BaseFooterProps<T> {
+  /**
+   * Function to confirm the form submission
+   */
+  onConfirm?: () => void;
+  /**
+   * Label for the submit button
+   */
+  submitLabel?: string;
+}
+/**
+ * Interface representing the environment for a footer component
+ * @template T - The type of record being used
+ */
+interface FooterEnvironment<T extends BaseRecord = any> {
+  /**
+   * The container environment
+   */
+  container: AnyContainerEnvironment;
+  /**
+   * The form environment
+   */
+  form: AnyFormEnvironment;
+  /**
+   * Optional step environment
+   */
+  step?: StepEnvironment;
+}
+/**
+ * Type guard to check if a footer environment has a step environment
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment has a step environment, false otherwise
+ */
+declare function hasStepEnvironment(ctx: FooterEnvironment): ctx is FooterEnvironment & {
+  step: StepEnvironment;
+};
+/**
+ * Type guard to check if a footer environment is a dialog footer environment
+ * @template T - The type of record being used
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment is a dialog footer environment, false otherwise
+ */
+declare function isDialogFooterEnvironment<T extends BaseRecord = any>(ctx: FooterEnvironment<T>): ctx is FooterEnvironment<T> & {
+  container: DialogContainerEnvironment;
+};
+/**
+ * Type guard to check if a footer environment is a simple footer environment
+ * @template T - The type of record being used
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment is a simple footer environment, false otherwise
+ */
+declare function isSimpleFooterEnvironment<T extends BaseRecord = any>(ctx: FooterEnvironment<T>): ctx is FooterEnvironment<T> & {
+  form: SimpleFormEnvironment;
+};
+/**
+ * Type guard to check if a footer environment is a standalone footer environment
+ * @template T - The type of record being used
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment is a standalone footer environment, false otherwise
+ */
+declare function isStandaloneFooterEnvironment<T extends BaseRecord = any>(ctx: FooterEnvironment<T>): ctx is FooterEnvironment<T> & {
+  container: StandaloneContainerEnvironment;
+};
+/**
+ * Type guard to check if a footer environment is a step footer environment
+ * @template T - The type of record being used
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment is a step footer environment, false otherwise
+ */
+declare function isStepFooterEnvironment<T extends BaseRecord = any>(ctx: FooterEnvironment<T>): ctx is FooterEnvironment<T> & {
+  form: StepFormEnvironment;
+};
+/**
+ * Type guard to check if a footer environment is a wizard footer environment
+ * @template T - The type of record being used
+ * @param ctx - The footer environment to check
+ * @returns True if the footer environment is a wizard footer environment, false otherwise
+ */
+declare function isWizardFooterEnvironment<T extends BaseRecord = any>(ctx: FooterEnvironment<T>): ctx is FooterEnvironment<T> & {
+  form: WizardFormEnvironment;
+};
+//#endregion
+export { BaseFooterProps, FooterEnvironment, FormFooterProps, hasStepEnvironment, isDialogFooterEnvironment, isSimpleFooterEnvironment, isStandaloneFooterEnvironment, isStepFooterEnvironment, isWizardFooterEnvironment };
+//# sourceMappingURL=footer.d.ts.map

package/dist/esm/components/shared/types/footer.js

@@ -0,0 +1,58 @@
+//#region src/components/shared/types/footer.ts
+/**
+* Type guard to check if a footer environment has a step environment
+* @param ctx - The footer environment to check
+* @returns True if the footer environment has a step environment, false otherwise
+*/
+function hasStepEnvironment(ctx) {
+	return ctx.step !== void 0;
+}
+/**
+* Type guard to check if a footer environment is a dialog footer environment
+* @template T - The type of record being used
+* @param ctx - The footer environment to check
+* @returns True if the footer environment is a dialog footer environment, false otherwise
+*/
+function isDialogFooterEnvironment(ctx) {
+	return ctx.container.type === "dialog";
+}
+/**
+* Type guard to check if a footer environment is a simple footer environment
+* @template T - The type of record being used
+* @param ctx - The footer environment to check
+* @returns True if the footer environment is a simple footer environment, false otherwise
+*/
+function isSimpleFooterEnvironment(ctx) {
+	return ctx.form.type === FormType.SIMPLE;
+}
+/**
+* Type guard to check if a footer environment is a standalone footer environment
+* @template T - The type of record being used
+* @param ctx - The footer environment to check
+* @returns True if the footer environment is a standalone footer environment, false otherwise
+*/
+function isStandaloneFooterEnvironment(ctx) {
+	return ctx.container.type === "standalone";
+}
+/**
+* Type guard to check if a footer environment is a step footer environment
+* @template T - The type of record being used
+* @param ctx - The footer environment to check
+* @returns True if the footer environment is a step footer environment, false otherwise
+*/
+function isStepFooterEnvironment(ctx) {
+	return ctx.form.type === FormType.STEP;
+}
+/**
+* Type guard to check if a footer environment is a wizard footer environment
+* @template T - The type of record being used
+* @param ctx - The footer environment to check
+* @returns True if the footer environment is a wizard footer environment, false otherwise
+*/
+function isWizardFooterEnvironment(ctx) {
+	return ctx.form.type === FormType.WIZARD;
+}
+
+//#endregion
+export { hasStepEnvironment, isDialogFooterEnvironment, isSimpleFooterEnvironment, isStandaloneFooterEnvironment, isStepFooterEnvironment, isWizardFooterEnvironment };
+//# sourceMappingURL=footer.js.map

package/dist/esm/components/shared/types/footer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.js","names":[],"sources":["../../../../../src/components/shared/types/footer.ts"],"sourcesContent":["import type { BaseRecord } from \"@refinedev/core\";\n\nimport { ActionItemConfig } from \"../../actions\";\nimport {\n  AnyContainerEnvironment,\n  DialogContainerEnvironment,\n  StandaloneContainerEnvironment,\n} from \"./container\";\nimport {\n  AnyFormEnvironment,\n  SimpleFormEnvironment,\n  StepFormEnvironment,\n  WizardFormEnvironment,\n} from \"./form\";\nimport { StepEnvironment } from \"./step\";\n\n/**\n * Interface representing the base props for a footer component\n * @template T - The type of record being used\n */\nexport interface BaseFooterProps<T extends BaseRecord = any> {\n  /**\n   * Optional array of action button configurations\n   */\n  actionButtons?: ActionItemConfig[];\n  /**\n   * Optional CSS class name\n   */\n  className?: string;\n  /**\n   * The environment configuration for the footer\n   */\n  environment: FooterEnvironment<T>;\n  /**\n   * Whether the form is currently submitting\n   */\n  isSubmitting?: boolean;\n  /**\n   * Function to close the container\n   */\n  onClose?: () => void;\n}\n\n/**\n * Interface representing the props for a form footer component\n * @template T - The type of record being used\n */\nexport interface FormFooterProps<T extends BaseRecord = any> extends BaseFooterProps<T> {\n  /**\n   * Function to confirm the form submission\n   */\n  onConfirm?: () => void;\n  /**\n   * Label for the submit button\n   */\n  submitLabel?: string;\n}\n\n// createFooterEnvironment function is now in environment/builders.ts\n\n/**\n * Interface representing the environment for a footer component\n * @template T - The type of record being used\n */\nexport interface FooterEnvironment<T extends BaseRecord = any> {\n  /**\n   * The container environment\n   */\n  container: AnyContainerEnvironment;\n  /**\n   * The form environment\n   */\n  form: AnyFormEnvironment;\n  /**\n   * Optional step environment\n   */\n  step?: StepEnvironment;\n}\n\n/**\n * Type guard to check if a footer environment has a step environment\n * @param ctx - The footer environment to check\n * @returns True if the footer environment has a step environment, false otherwise\n */\nexport function hasStepEnvironment(\n  ctx: FooterEnvironment,\n): ctx is FooterEnvironment & { step: StepEnvironment } {\n  return ctx.step !== undefined;\n}\n\n/**\n * Type guard to check if a footer environment is a dialog footer environment\n * @template T - The type of record being used\n * @param ctx - The footer environment to check\n * @returns True if the footer environment is a dialog footer environment, false otherwise\n */\nexport function isDialogFooterEnvironment<T extends BaseRecord = any>(\n  ctx: FooterEnvironment<T>,\n): ctx is FooterEnvironment<T> & { container: DialogContainerEnvironment } {\n  return ctx.container.type === \"dialog\";\n}\n\n/**\n * Type guard to check if a footer environment is a simple footer environment\n * @template T - The type of record being used\n * @param ctx - The footer environment to check\n * @returns True if the footer environment is a simple footer environment, false otherwise\n */\nexport function isSimpleFooterEnvironment<T extends BaseRecord = any>(\n  ctx: FooterEnvironment<T>,\n): ctx is FooterEnvironment<T> & { form: SimpleFormEnvironment } {\n  return ctx.form.type === FormType.SIMPLE;\n}\n\n/**\n * Type guard to check if a footer environment is a standalone footer environment\n * @template T - The type of record being used\n * @param ctx - The footer environment to check\n * @returns True if the footer environment is a standalone footer environment, false otherwise\n */\nexport function isStandaloneFooterEnvironment<T extends BaseRecord = any>(\n  ctx: FooterEnvironment<T>,\n): ctx is FooterEnvironment<T> & { container: StandaloneContainerEnvironment } {\n  return ctx.container.type === \"standalone\";\n}\n\n/**\n * Type guard to check if a footer environment is a step footer environment\n * @template T - The type of record being used\n * @param ctx - The footer environment to check\n * @returns True if the footer environment is a step footer environment, false otherwise\n */\nexport function isStepFooterEnvironment<T extends BaseRecord = any>(\n  ctx: FooterEnvironment<T>,\n): ctx is FooterEnvironment<T> & { form: StepFormEnvironment } {\n  return ctx.form.type === FormType.STEP;\n}\n\n/**\n * Type guard to check if a footer environment is a wizard footer environment\n * @template T - The type of record being used\n * @param ctx - The footer environment to check\n * @returns True if the footer environment is a wizard footer environment, false otherwise\n */\nexport function isWizardFooterEnvironment<T extends BaseRecord = any>(\n  ctx: FooterEnvironment<T>,\n): ctx is FooterEnvironment<T> & { form: WizardFormEnvironment } {\n  return ctx.form.type === FormType.WIZARD;\n}\n"],"mappings":";;;;;;AAoFA,SAAgB,mBACd,KACsD;AACtD,QAAO,IAAI,SAAS;;;;;;;;AAStB,SAAgB,0BACd,KACyE;AACzE,QAAO,IAAI,UAAU,SAAS;;;;;;;;AAShC,SAAgB,0BACd,KAC+D;AAC/D,QAAO,IAAI,KAAK,SAAS,SAAS;;;;;;;;AASpC,SAAgB,8BACd,KAC6E;AAC7E,QAAO,IAAI,UAAU,SAAS;;;;;;;;AAShC,SAAgB,wBACd,KAC6D;AAC7D,QAAO,IAAI,KAAK,SAAS,SAAS;;;;;;;;AASpC,SAAgB,0BACd,KAC+D;AAC/D,QAAO,IAAI,KAAK,SAAS,SAAS"}

package/dist/esm/components/shared/types/form.d.ts

@@ -0,0 +1,120 @@
+//#region src/components/shared/types/form.d.ts
+/**
+ * Type for the force rerender method that can be called to trigger a component rerender
+ */
+type ForceRerenderMethod = () => void;
+/**
+ * Callback function type for receiving the force rerender method
+ * This is a "reverse callback" where the framework calls this callback with a method
+ * that can be stored locally and used to force a rerender when something outside
+ * the render loop needs it
+ */
+type ForceRerenderCallback = (forceRerender: ForceRerenderMethod) => void;
+/**
+ * Callback function type for receiving environment updates
+ * This is a callback that can be called directly with the environment
+ * when it needs to be synced
+ */
+type EnvironmentSyncCallback = (environment: UnifiedEnvironment) => void;
+/**
+ * Enum representing the different types of forms
+ */
+declare enum FormType {
+  /**
+   * Simple form type
+   */
+  SIMPLE = "simple",
+  /**
+   * Step form type
+   */
+  STEP = "step",
+  /**
+   * Wizard form type
+   */
+  WIZARD = "wizard"
+}
+/**
+ * Union type representing any form environment
+ */
+type AnyFormEnvironment = SimpleFormEnvironment | StepFormEnvironment | WizardFormEnvironment;
+/**
+ * Base interface for form environment
+ */
+interface FormEnvironment {
+  /**
+   * The type of form
+   */
+  type: FormType;
+}
+/**
+ * Interface representing a simple form environment
+ */
+interface SimpleFormEnvironment extends FormEnvironment {
+  /**
+   * Whether the form is currently submitting
+   */
+  isSubmitting?: boolean;
+  /**
+   * React Hook Form methods
+   */
+  methods: any;
+  /**
+   * The type of form (simple)
+   */
+  type: FormType.SIMPLE;
+}
+/**
+ * Interface representing a step form environment
+ */
+interface StepFormEnvironment extends FormEnvironment {
+  /**
+   * Whether the form is currently submitting
+   */
+  isSubmitting?: boolean;
+  /**
+   * React Hook Form methods
+   */
+  methods: any;
+  /**
+   * The type of form (step)
+   */
+  type: FormType.STEP;
+}
+/**
+ * Interface representing a wizard form environment
+ */
+interface WizardFormEnvironment extends FormEnvironment {
+  /**
+   * Whether the form is currently submitting
+   */
+  isSubmitting: boolean;
+  /**
+   * React Hook Form methods
+   */
+  methods: any;
+  /**
+   * The type of form (wizard)
+   */
+  type: FormType.WIZARD;
+}
+/**
+ * Type guard to check if a form environment is a simple form
+ * @param ctx - The form environment to check
+ * @returns True if the form environment is a simple form, false otherwise
+ */
+declare function isSimpleForm(ctx: AnyFormEnvironment | undefined): ctx is SimpleFormEnvironment;
+/**
+ * Type guard to check if a form environment is a step form
+ * @param ctx - The form environment to check
+ * @returns True if the form environment is a step form, false otherwise
+ */
+declare function isStepForm(ctx: AnyFormEnvironment | undefined): ctx is StepFormEnvironment;
+/**
+ * Type guard to check if a form environment is a wizard form
+ * @param ctx - The form environment to check
+ * @returns True if the form environment is a wizard form, false otherwise
+ */
+declare function isWizardForm(ctx: AnyFormEnvironment | undefined): ctx is WizardFormEnvironment;
+//#endregion
+export { AnyFormEnvironment, EnvironmentSyncCallback, ForceRerenderCallback, ForceRerenderMethod, FormEnvironment, FormType, SimpleFormEnvironment, StepFormEnvironment, WizardFormEnvironment, isSimpleForm, isStepForm, isWizardForm };
+//# sourceMappingURL=form.d.ts.map