@gnwebsoft/ui 4.0.1 → 4.0.3

package/dist/chunk-EYXPJMEF.cjs

@@ -0,0 +1,108 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/i18n/I18nContext.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var I18nContext = _react.createContext.call(void 0, null);
+I18nContext.displayName = "I18nContext";
+var NamespaceContext = _react.createContext.call(void 0, 
+  null
+);
+NamespaceContext.displayName = "NamespaceContext";
+function I18nProvider({
+  t,
+  currentLanguage,
+  children
+}) {
+  const value = _react.useMemo.call(void 0, 
+    () => ({
+      t,
+      currentLanguage
+    }),
+    [t, currentLanguage]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, I18nContext.Provider, { value, children });
+}
+I18nProvider.displayName = "I18nProvider";
+function TranslationNamespace({
+  namespace,
+  children
+}) {
+  const parentContext = _react.useContext.call(void 0, NamespaceContext);
+  const value = _react.useMemo.call(void 0, () => {
+    const fullNamespace = parentContext ? `${parentContext.namespace}.${namespace}` : namespace;
+    return { namespace: fullNamespace };
+  }, [namespace, parentContext]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NamespaceContext.Provider, { value, children });
+}
+TranslationNamespace.displayName = "TranslationNamespace";
+function useNamespace() {
+  const context = _react.useContext.call(void 0, NamespaceContext);
+  return _optionalChain([context, 'optionalAccess', _ => _.namespace]);
+}
+function useI18n(namespaceOverride) {
+  const i18nContext = _react.useContext.call(void 0, I18nContext);
+  const namespaceContext = _react.useContext.call(void 0, NamespaceContext);
+  const namespace = _nullishCoalesce(namespaceOverride, () => ( _optionalChain([namespaceContext, 'optionalAccess', _2 => _2.namespace])));
+  if (!i18nContext) {
+    return {
+      t: (key) => {
+        return namespace ? `${namespace}.${key}` : key;
+      },
+      currentLanguage: void 0
+    };
+  }
+  if (namespace) {
+    return {
+      ...i18nContext,
+      t: (key, options) => {
+        const prefixedKey = `${namespace}.${key}`;
+        return i18nContext.t(prefixedKey, options);
+      }
+    };
+  }
+  return i18nContext;
+}
+function resolveLabel(t, label, labelKey, namespace, contextNamespace, options) {
+  if (label !== void 0) {
+    return label;
+  }
+  if (labelKey) {
+    const effectiveNamespace = _nullishCoalesce(namespace, () => ( contextNamespace));
+    const fullKey = effectiveNamespace ? `${effectiveNamespace}.${labelKey}` : labelKey;
+    return t(fullKey, options);
+  }
+  return void 0;
+}
+function useFormI18n() {
+  const i18nContext = _react.useContext.call(void 0, I18nContext);
+  const namespaceContext = _react.useContext.call(void 0, NamespaceContext);
+  const contextNamespace = _optionalChain([namespaceContext, 'optionalAccess', _3 => _3.namespace]);
+  const t = _nullishCoalesce(_optionalChain([i18nContext, 'optionalAccess', _4 => _4.t]), () => ( ((key) => key)));
+  const resolve = (label, labelKey, namespaceOverride, options) => {
+    return resolveLabel(
+      t,
+      label,
+      labelKey,
+      namespaceOverride,
+      contextNamespace,
+      options
+    );
+  };
+  return {
+    t,
+    currentLanguage: _optionalChain([i18nContext, 'optionalAccess', _5 => _5.currentLanguage]),
+    namespace: contextNamespace,
+    resolveLabel: resolve
+  };
+}
+
+
+
+
+
+
+
+
+
+
+exports.I18nContext = I18nContext; exports.NamespaceContext = NamespaceContext; exports.I18nProvider = I18nProvider; exports.TranslationNamespace = TranslationNamespace; exports.useNamespace = useNamespace; exports.useI18n = useI18n; exports.resolveLabel = resolveLabel; exports.useFormI18n = useFormI18n;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-FYU2OIMD.js

@@ -0,0 +1,15 @@
+// src/utils/readValueAsDate.ts
+function readValueAsDate(adapter, value) {
+  if (typeof value === "string") {
+    if (value === "") {
+      return null;
+    }
+    return adapter.utils.date(value);
+  }
+  return value;
+}
+
+export {
+  readValueAsDate
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL3V0aWxzL3JlYWRWYWx1ZUFzRGF0ZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBQaWNrZXJWYWxpZERhdGUgfSBmcm9tIFwiQG11aS94LWRhdGUtcGlja2Vyc1wiO1xuaW1wb3J0IHR5cGUgeyB1c2VMb2NhbGl6YXRpb25Db250ZXh0IH0gZnJvbSBcIkBtdWkveC1kYXRlLXBpY2tlcnMvaW50ZXJuYWxzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWFkVmFsdWVBc0RhdGU8VERhdGUgZXh0ZW5kcyBQaWNrZXJWYWxpZERhdGU+KFxuICBhZGFwdGVyOiBSZXR1cm5UeXBlPHR5cGVvZiB1c2VMb2NhbGl6YXRpb25Db250ZXh0PixcbiAgdmFsdWU6IHN0cmluZyB8IG51bGwgfCBURGF0ZVxuKTogVERhdGUgfCBudWxsIHtcbiAgaWYgKHR5cGVvZiB2YWx1ZSA9PT0gXCJzdHJpbmdcIikge1xuICAgIGlmICh2YWx1ZSA9PT0gXCJcIikge1xuICAgICAgcmV0dXJuIG51bGw7XG4gICAgfVxuXG4gICAgcmV0dXJuIGFkYXB0ZXIudXRpbHMuZGF0ZSh2YWx1ZSkgYXMgVERhdGU7XG4gIH1cblxuICByZXR1cm4gdmFsdWU7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBR08sU0FBUyxnQkFDZCxTQUNBLE9BQ2M7QUFDZCxNQUFJLE9BQU8sVUFBVSxVQUFVO0FBQzdCLFFBQUksVUFBVSxJQUFJO0FBQ2hCLGFBQU87QUFBQSxJQUNUO0FBRUEsV0FBTyxRQUFRLE1BQU0sS0FBSyxLQUFLO0FBQUEsRUFDakM7QUFFQSxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/chunk-GHW77WIM.cjs

@@ -69,4 +69,4 @@ function typedValues(obj) {
 
 
 exports.isJsonObject = isJsonObject; exports.isJsonArray = isJsonArray; exports.isFormData = isFormData; exports.isRequestBody = isRequestBody; exports.isInputChangeEvent = isInputChangeEvent; exports.isSelectChangeEvent = isSelectChangeEvent; exports.isFormChangeEvent = isFormChangeEvent; exports.extractEventValue = extractEventValue; exports.createEventValueExtractor = createEventValueExtractor; exports.brand = brand; exports.typedKeys = typedKeys; exports.typedEntries = typedEntries; exports.typedValues = typedValues;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImQ6XFxQcm9qZWN0c1xcR05XZWJTb2Z0LlVJXFxwYWNrYWdlc1xcdWlcXGRpc3RcXGNodW5rLUdIVzc3V0lNLmNqcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUNBLFNBQVMsWUFBWSxDQUFDLEtBQUssRUFBRTtBQUM3QixFQUFFLE9BQU8sT0FBTyxNQUFNLElBQUksU0FBUyxHQUFHLE1BQU0sSUFBSSxLQUFLLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQyxNQUFNLFdBQVcsUUFBUSxDQUFDO0FBQzdHO0FBQ0EsU0FBUyxXQUFXLENBQUMsS0FBSyxFQUFFO0FBQzVCLEVBQUUsT0FBTyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztBQUM3QjtBQUNBLFNBQVMsVUFBVSxDQUFDLEtBQUssRUFBRTtBQUMzQixFQUFFLE9BQU8sTUFBTSxXQUFXLFFBQVE7QUFDbEM7QUFDQSxTQUFTLGFBQWEsQ0FBQyxLQUFLLEVBQUU7QUFDOUIsRUFBRSxPQUFPLFlBQVksQ0FBQyxLQUFLLEVBQUUsR0FBRyxXQUFXLENBQUMsS0FBSyxFQUFFLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQztBQUN2RTtBQUNBO0FBQ0E7QUFDQSxTQUFTLGtCQUFrQixDQUFDLEtBQUssRUFBRTtBQUNuQyxFQUFFLE9BQU8sT0FBTyxNQUFNLElBQUksU0FBUyxHQUFHLE1BQU0sSUFBSSxLQUFLLEdBQUcsU0FBUyxHQUFHLE1BQU0sR0FBRyxPQUFPLEtBQUssQ0FBQyxPQUFPLElBQUksU0FBUyxHQUFHLEtBQUssQ0FBQyxPQUFPLElBQUksS0FBSyxHQUFHLFFBQVEsR0FBRyxLQUFLLENBQUMsTUFBTTtBQUNqSztBQUNBLFNBQVMsbUJBQW1CLENBQUMsS0FBSyxFQUFFO0FBQ3BDLEVBQUUsT0FBTyxrQkFBa0IsQ0FBQyxLQUFLLENBQUM7QUFDbEM7QUFDQSxTQUFTLGlCQUFpQixDQUFDLEtBQUssRUFBRTtBQUNsQyxFQUFFLE9BQU8sa0JBQWtCLENBQUMsS0FBSyxFQUFFLEdBQUcsbUJBQW1CLENBQUMsS0FBSyxDQUFDO0FBQ2hFO0FBQ0EsU0FBUyxpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFO0FBQ3hELEVBQUUsR0FBRyxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxFQUFFO0FBQ3ZDLElBQUksT0FBTyxZQUFZLENBQUMsTUFBTSxDQUFDLEtBQUs7QUFDcEMsRUFBRTtBQUNGLEVBQUUsR0FBRyxDQUFDLE9BQU8sYUFBYSxJQUFJLFNBQVMsR0FBRyxhQUFhLElBQUksS0FBSyxHQUFHLFNBQVMsR0FBRyxhQUFhLEdBQUcsT0FBTyxZQUFZLENBQUMsT0FBTyxJQUFJLFNBQVMsR0FBRyxZQUFZLENBQUMsT0FBTyxJQUFJLEtBQUssR0FBRyxRQUFRLEdBQUcsWUFBWSxDQUFDLE1BQU0sRUFBRTtBQUMxTSxJQUFJLE9BQU8sWUFBWSxDQUFDLE1BQU0sQ0FBQyxLQUFLO0FBQ3BDLEVBQUU7QUFDRixFQUFFLHdCQUFPLFlBQWEsVUFBRyxlQUFhO0FBQ3RDO0FBQ0EsU0FBUyx5QkFBeUIsQ0FBQyxFQUFFO0FBQ3JDLEVBQUUsT0FBTyxDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsR0FBRztBQUN4QyxJQUFJLEdBQUcsQ0FBQyxZQUFZLElBQUksS0FBSyxDQUFDLEVBQUU7QUFDaEMsTUFBTSxPQUFPLFdBQVc7QUFDeEIsSUFBSTtBQUNKLElBQUksT0FBTyxpQkFBaUIsQ0FBQyxZQUFZLENBQUM7QUFDMUMsRUFBRSxDQUFDO0FBQ0g7QUFDQTtBQUNBO0FBQ0EsU0FBUyxLQUFLLENBQUMsS0FBSyxFQUFFO0FBQ3RCLEVBQUUsT0FBTyxLQUFLO0FBQ2Q7QUFDQSxTQUFTLFNBQVMsQ0FBQyxHQUFHLEVBQUU7QUFDeEIsRUFBRSxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDO0FBQ3pCO0FBQ0EsU0FBUyxZQUFZLENBQUMsR0FBRyxFQUFFO0FBQzNCLEVBQUUsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQztBQUM1QjtBQUNBLFNBQVMsV0FBVyxDQUFDLEdBQUcsRUFBRTtBQUMxQixFQUFFLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7QUFDM0I7QUFDQTtBQUNBO0FBQ0U7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDRiw4Z0JBQUMiLCJmaWxlIjoiRDpcXFByb2plY3RzXFxHTldlYlNvZnQuVUlcXHBhY2thZ2VzXFx1aVxcZGlzdFxcY2h1bmstR0hXNzdXSU0uY2pzIiwic291cmNlc0NvbnRlbnQiOltudWxsXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-GVWCGJ3F.js

@@ -0,0 +1,140 @@
+// src/hooks/useTransform/index.ts
+function useTransform(options) {
+  const value = typeof options.transform?.input === "function" ? options.transform.input(options.value) : options.value;
+  const onChange = (eventOrValue, value2) => {
+    if (typeof options.transform?.output === "function") {
+      options.onChange(options.transform.output(eventOrValue, value2));
+    } else {
+      options.onChange(eventOrValue);
+    }
+  };
+  return {
+    value,
+    onChange
+  };
+}
+
+// src/hooks/useTransform/enhanced.ts
+import { useCallback, useMemo } from "react";
+var transformFactories = {
+  number: () => ({
+    input: (value) => {
+      if (value == null) return "";
+      return String(value);
+    },
+    output: (eventOrValue, _value) => {
+      let rawValue;
+      if (typeof eventOrValue === "object" && eventOrValue !== null && "target" in eventOrValue && typeof eventOrValue.target === "object" && eventOrValue.target !== null && "value" in eventOrValue.target) {
+        rawValue = String(eventOrValue.target.value);
+      } else {
+        rawValue = String(eventOrValue);
+      }
+      if (rawValue === "") return null;
+      const numValue = Number(rawValue);
+      return isNaN(numValue) ? null : numValue;
+    }
+  }),
+  text: () => ({
+    input: (value) => {
+      return value ?? "";
+    },
+    output: (eventOrValue, _value) => {
+      if (typeof eventOrValue === "object" && eventOrValue !== null && "target" in eventOrValue && typeof eventOrValue.target === "object" && eventOrValue.target !== null && "value" in eventOrValue.target) {
+        return eventOrValue.target.value;
+      }
+      return eventOrValue;
+    }
+  }),
+  select: () => ({
+    input: (value) => {
+      return value ?? "";
+    },
+    output: (eventOrValue, value) => {
+      if (value !== void 0) {
+        return value;
+      }
+      if (typeof eventOrValue === "object" && eventOrValue !== null && "target" in eventOrValue && typeof eventOrValue.target === "object" && eventOrValue.target !== null && "value" in eventOrValue.target) {
+        return eventOrValue.target.value;
+      }
+      return eventOrValue;
+    }
+  })
+};
+function getBuiltInTransform(fieldType) {
+  switch (fieldType) {
+    case "number":
+      return transformFactories.number();
+    case "text":
+      return transformFactories.text();
+    case "select":
+    case "radio":
+      return transformFactories.select();
+    default:
+      return void 0;
+  }
+}
+function useEnhancedTransform(options) {
+  const {
+    value: fieldValue,
+    onChange: fieldOnChange,
+    transform,
+    fieldType,
+    defaultValue,
+    enableWarnings
+  } = options;
+  const builtInTransform = useMemo(
+    () => fieldType ? getBuiltInTransform(fieldType) : void 0,
+    [fieldType]
+  );
+  if (enableWarnings && process.env.NODE_ENV === "development") {
+    if (transform && fieldType) {
+      console.warn(
+        "useEnhancedTransform: Both custom transform and fieldType provided. Custom transform will take precedence."
+      );
+    }
+  }
+  const transformedValue = useMemo(() => {
+    const inputTransform = transform?.input || builtInTransform?.input;
+    if (typeof inputTransform === "function") {
+      return inputTransform(fieldValue);
+    }
+    if (fieldValue == null && defaultValue !== void 0) {
+      return defaultValue;
+    }
+    return fieldValue;
+  }, [fieldValue, transform?.input, builtInTransform?.input, defaultValue]);
+  const enhancedOnChange = useCallback(
+    (eventOrValue, value) => {
+      const outputTransform = transform?.output || builtInTransform?.output;
+      if (typeof outputTransform === "function") {
+        try {
+          const transformedValue2 = outputTransform(eventOrValue, value);
+          fieldOnChange(transformedValue2);
+        } catch (error) {
+          if (enableWarnings && process.env.NODE_ENV === "development") {
+            console.error("useEnhancedTransform: Error in output transformation:", error);
+          }
+          fieldOnChange(
+            value !== void 0 ? value : eventOrValue
+          );
+        }
+      } else {
+        fieldOnChange(
+          value !== void 0 ? value : eventOrValue
+        );
+      }
+    },
+    [fieldOnChange, transform?.output, builtInTransform?.output, enableWarnings]
+  );
+  return {
+    value: transformedValue,
+    onChange: enhancedOnChange
+  };
+}
+
+export {
+  useTransform,
+  transformFactories,
+  useEnhancedTransform
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/hooks/useTransform/index.ts", "../src/hooks/useTransform/enhanced.ts"],
  "sourcesContent": ["import type {\n  FieldPath,\n  FieldValues,\n  PathValue,\n  UseControllerReturn,\n} from \"react-hook-form\";\n\nimport type { EventOrValue } from \"../../types/events\";\n\n/**\n * Options for the useTransform hook.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface UseTransformOptions<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown,\n> {\n  /** The current field value from react-hook-form */\n  value: UseControllerReturn<TFieldValues, TName>[\"field\"][\"value\"];\n  /** The onChange handler from react-hook-form */\n  onChange: UseControllerReturn<TFieldValues, TName>[\"field\"][\"onChange\"];\n  /** Optional transformation functions */\n  transform?: {\n    /**\n     * Transform the field value for display in the input\n     * @param value - The current field value\n     * @returns The transformed value to display\n     */\n    input?: (value: PathValue<TFieldValues, TName>) => TValue;\n    /**\n     * Transform the input event back to the field value\n     * @param event - The input event parameters\n     * @returns The transformed value to store in the form\n     */\n    output?: (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n}\n\n/**\n * Return type for the useTransform hook.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface UseTransformReturn<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown,\n> {\n  /** The transformed value to display in the input */\n  value: TValue;\n  /** The enhanced onChange handler with transformation applied */\n  onChange: UseControllerReturn<TFieldValues, TName>[\"field\"][\"onChange\"];\n}\n\n/**\n * A hook for transforming form field values between display and storage formats.\n *\n * This hook provides a way to transform values as they flow between the form field\n * and the display component. It's particularly useful for formatting data for display\n * (like dates, numbers, or complex objects) while maintaining a different internal\n * representation in the form state.\n *\n * @example\n * Transform a date for display:\n * ```tsx\n * const { value, onChange } = useTransform({\n *   value: field.value,\n *   onChange: field.onChange,\n *   transform: {\n *     input: (date) => date ? format(date, 'yyyy-MM-dd') : '',\n *     output: (event) => new Date(event.target.value)\n *   }\n * });\n * ```\n *\n * @example\n * Transform numbers with formatting:\n * ```tsx\n * const { value, onChange } = useTransform({\n *   value: field.value,\n *   onChange: field.onChange,\n *   transform: {\n *     input: (num) => num ? num.toLocaleString() : '',\n *     output: (event) => parseFloat(event.target.value.replace(/,/g, ''))\n *   }\n * });\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @param options - Configuration options including value, onChange, and transform functions\n * @returns Object with transformed value and enhanced onChange handler\n *\n * @public\n */\nexport function useTransform<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown,\n>(\n  options: UseTransformOptions<TFieldValues, TName, TValue>\n): UseTransformReturn<TFieldValues, TName, TValue> {\n  const value =\n    typeof options.transform?.input === \"function\"\n      ? options.transform.input(options.value)\n      : options.value;\n\n  const onChange = (\n    eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n    value?: PathValue<TFieldValues, TName>\n  ): void => {\n    if (typeof options.transform?.output === \"function\") {\n      options.onChange(options.transform.output(eventOrValue, value));\n    } else {\n      // Pass through the event or value directly\n      options.onChange(eventOrValue as PathValue<TFieldValues, TName>);\n    }\n  };\n\n  return {\n    value,\n    onChange,\n  };\n}\n\nexport default useTransform;\n", "import { useCallback, useMemo } from \"react\";\nimport type {\n  FieldPath,\n  FieldValues,\n  PathValue,\n  UseControllerReturn,\n} from \"react-hook-form\";\n\nimport type { EventOrValue } from \"../../types/events\";\n\n/**\n * Field types for built-in transformation patterns\n */\nexport type FieldType = 'text' | 'number' | 'date' | 'time' | 'select' | 'radio';\n\n/**\n * Enhanced options for the useTransform hook with performance optimizations\n * and built-in field type handling.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface EnhancedUseTransformOptions<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>,\n> {\n  /** The current field value from react-hook-form */\n  value: UseControllerReturn<TFieldValues, TName>[\"field\"][\"value\"];\n  /** The onChange handler from react-hook-form */\n  onChange: UseControllerReturn<TFieldValues, TName>[\"field\"][\"onChange\"];\n  /** Optional transformation functions */\n  transform?: {\n    /**\n     * Transform the field value for display in the input\n     * @param value - The current field value\n     * @returns The transformed value to display\n     */\n    input?: (value: PathValue<TFieldValues, TName>) => TValue;\n    /**\n     * Transform the input event back to the field value\n     * @param event - The input event or value\n     * @returns The transformed value to store in the form\n     */\n    output?: (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n  /** Built-in field type for automatic transformation */\n  fieldType?: FieldType;\n  /** Default value to use when field value is null/undefined */\n  defaultValue?: TValue;\n  /** Enable development warnings for debugging */\n  enableWarnings?: boolean;\n}\n\n/**\n * Enhanced return type for the useTransform hook with stable references\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type  \n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface EnhancedUseTransformReturn<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>,\n> {\n  /** The transformed value to display in the input (memoized) */\n  value: TValue;\n  /** The enhanced onChange handler with transformation applied (memoized) */\n  onChange: UseControllerReturn<TFieldValues, TName>[\"field\"][\"onChange\"];\n}\n\n/**\n * Transform factories for common field types\n */\nexport const transformFactories = {\n  number: <TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues>>() => ({\n    input: (value: PathValue<TFieldValues, TName>) => {\n      if (value == null) return \"\" as string;\n\n      return String(value);\n    },\n    output: (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      _value?: PathValue<TFieldValues, TName>\n    ) => {\n      let rawValue: string;\n      \n      // Extract string value from event or direct value\n      if (\n        typeof eventOrValue === 'object' &&\n        eventOrValue !== null &&\n        'target' in eventOrValue &&\n        typeof eventOrValue.target === 'object' &&\n        eventOrValue.target !== null &&\n        'value' in eventOrValue.target\n      ) {\n        rawValue = String((eventOrValue.target as unknown as { value: unknown }).value);\n      } else {\n        rawValue = String(eventOrValue);\n      }\n\n      if (rawValue === \"\") return null as PathValue<TFieldValues, TName>;\n      const numValue = Number(rawValue);\n\n      return (isNaN(numValue) ? null : numValue) as PathValue<TFieldValues, TName>;\n    },\n  }),\n\n  text: <TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues>>() => ({\n    input: (value: PathValue<TFieldValues, TName>) => {\n      return (value ?? \"\") as string;\n    },\n    output: (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      _value?: PathValue<TFieldValues, TName>\n    ) => {\n      // Extract string value from event or direct value\n      if (\n        typeof eventOrValue === 'object' &&\n        eventOrValue !== null &&\n        'target' in eventOrValue &&\n        typeof eventOrValue.target === 'object' &&\n        eventOrValue.target !== null &&\n        'value' in eventOrValue.target\n      ) {\n        return (eventOrValue.target as unknown as { value: PathValue<TFieldValues, TName> }).value;\n      }\n      \n      return eventOrValue as PathValue<TFieldValues, TName>;\n    },\n  }),\n\n  select: <TFieldValues extends FieldValues, TName extends FieldPath<TFieldValues>>() => ({\n    input: (value: PathValue<TFieldValues, TName>) => {\n      return value ?? (\"\" as string);\n    },\n    output: (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => {\n      // MUI pattern: (event, value) where value is the actual selected value\n      if (value !== undefined) {\n        return value as PathValue<TFieldValues, TName>;\n      }\n      \n      // Standard event pattern: extract from event.target.value\n      if (\n        typeof eventOrValue === 'object' &&\n        eventOrValue !== null &&\n        'target' in eventOrValue &&\n        typeof eventOrValue.target === 'object' &&\n        eventOrValue.target !== null &&\n        'value' in eventOrValue.target\n      ) {\n        return (eventOrValue.target as unknown as { value: PathValue<TFieldValues, TName> }).value;\n      }\n      \n      // Direct value\n      return eventOrValue as PathValue<TFieldValues, TName>;\n    },\n  }),\n} as const;;\n\n/**\n * Get built-in transformation for a field type\n */\nfunction getBuiltInTransform<\n  TFieldValues extends FieldValues,\n  TName extends FieldPath<TFieldValues>,\n>(fieldType?: FieldType) {\n  switch (fieldType) {\n    case 'number':\n      return transformFactories.number<TFieldValues, TName>();\n    case 'text':\n      return transformFactories.text<TFieldValues, TName>();\n    case 'select':\n    case 'radio':\n      return transformFactories.select<TFieldValues, TName>();\n    default:\n      return undefined;\n  }\n}\n\n/**\n * An enhanced hook for transforming form field values with performance optimizations\n * and built-in field type handling.\n *\n * This enhanced version provides:\n * - Performance optimizations with useMemo and useCallback\n * - Built-in transformations for common field types\n * - Better TypeScript inference\n * - Development warnings\n * - Stable references to prevent unnecessary re-renders\n *\n * @example\n * Basic usage with built-in number handling:\n * ```tsx\n * const { value, onChange } = useEnhancedTransform({\n *   value: field.value,\n *   onChange: field.onChange,\n *   fieldType: 'number'\n * });\n * ```\n *\n * @example\n * Custom transformations (same as original):\n * ```tsx\n * const { value, onChange } = useEnhancedTransform({\n *   value: field.value,\n *   onChange: field.onChange,\n *   transform: {\n *     input: (value) => value?.toString() || '',\n *     output: (event) => parseInt(event.target.value) || null\n *   }\n * });\n * ```\n *\n * @example\n * With default value and warnings:\n * ```tsx\n * const { value, onChange } = useEnhancedTransform({\n *   value: field.value,\n *   onChange: field.onChange,\n *   fieldType: 'text',\n *   defaultValue: '',\n *   enableWarnings: process.env.NODE_ENV === 'development'\n * });\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @param options - Configuration options including value, onChange, and transform functions\n * @returns Object with transformed value and enhanced onChange handler (both memoized)\n *\n * @public\n */\nexport function useEnhancedTransform<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>,\n>(\n  options: EnhancedUseTransformOptions<TFieldValues, TName, TValue>\n): EnhancedUseTransformReturn<TFieldValues, TName, TValue> {\n  const { \n    value: fieldValue, \n    onChange: fieldOnChange, \n    transform, \n    fieldType, \n    defaultValue,\n    enableWarnings \n  } = options;\n\n  // Get built-in transform if fieldType is specified\n  const builtInTransform = useMemo(() => \n    fieldType ? getBuiltInTransform<TFieldValues, TName>(fieldType) : undefined, \n    [fieldType]\n  );\n\n  // Development warnings\n  if (enableWarnings && process.env.NODE_ENV === 'development') {\n    if (transform && fieldType) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'useEnhancedTransform: Both custom transform and fieldType provided. Custom transform will take precedence.'\n      );\n    }\n  }\n\n  // Memoize the transformed display value\n  const transformedValue = useMemo((): TValue => {\n    const inputTransform = transform?.input || builtInTransform?.input;\n    \n    if (typeof inputTransform === \"function\") {\n      return inputTransform(fieldValue) as TValue;\n    }\n    \n    // Fallback with default value support\n    if (fieldValue == null && defaultValue !== undefined) {\n      return defaultValue;\n    }\n    \n    return fieldValue as TValue;\n  }, [fieldValue, transform?.input, builtInTransform?.input, defaultValue]);\n\n  // Memoize the enhanced onChange handler\n  const enhancedOnChange = useCallback(\n    (\n      eventOrValue: EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => {\n      const outputTransform = transform?.output || builtInTransform?.output;\n      \n      if (typeof outputTransform === \"function\") {\n        try {\n          // Handle both signatures: old (event only) and new (event, value)\n          const transformedValue = (outputTransform as (e: EventOrValue<PathValue<TFieldValues, TName>>, v?: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName>)(eventOrValue, value);\n\n          fieldOnChange(transformedValue);\n        } catch (error) {\n          if (enableWarnings && process.env.NODE_ENV === 'development') {\n            // eslint-disable-next-line no-console\n            console.error('useEnhancedTransform: Error in output transformation:', error);\n          }\n\n          // Fallback to direct value or first argument\n          fieldOnChange(\n            value !== undefined \n              ? value \n              : eventOrValue as PathValue<TFieldValues, TName>\n          );\n        }\n      } else {\n        // No transform, pass through the value or event\n        fieldOnChange(\n          value !== undefined \n            ? value \n            : eventOrValue as PathValue<TFieldValues, TName>\n        );\n      }\n    },\n    [fieldOnChange, transform?.output, builtInTransform?.output, enableWarnings]\n  );\n\n  return {\n    value: transformedValue,\n    onChange: enhancedOnChange,\n  };\n}\n\nexport default useEnhancedTransform;"],
  "mappings": "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",
  "names": ["value", "transformedValue"]
}


package/dist/chunk-LUW7V5GI.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/readValueAsDate.ts
+function readValueAsDate(adapter, value) {
+  if (typeof value === "string") {
+    if (value === "") {
+      return null;
+    }
+    return adapter.utils.date(value);
+  }
+  return value;
+}
+
+
+
+exports.readValueAsDate = readValueAsDate;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImM6XFxVdHRhbVxcUHJvamVjdHNcXEdOV2ViU29mdC5VSVxccGFja2FnZXNcXHVpXFxkaXN0XFxjaHVuay1MVVc3VjVHSS5janMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQSxTQUFTLGVBQWUsQ0FBQyxPQUFPLEVBQUUsS0FBSyxFQUFFO0FBQ3pDLEVBQUUsR0FBRyxDQUFDLE9BQU8sTUFBTSxJQUFJLFFBQVEsRUFBRTtBQUNqQyxJQUFJLEdBQUcsQ0FBQyxNQUFNLElBQUksRUFBRSxFQUFFO0FBQ3RCLE1BQU0sT0FBTyxJQUFJO0FBQ2pCLElBQUk7QUFDSixJQUFJLE9BQU8sT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO0FBQ3BDLEVBQUU7QUFDRixFQUFFLE9BQU8sS0FBSztBQUNkO0FBQ0E7QUFDQTtBQUNFO0FBQ0YsMENBQUMiLCJmaWxlIjoiQzpcXFV0dGFtXFxQcm9qZWN0c1xcR05XZWJTb2Z0LlVJXFxwYWNrYWdlc1xcdWlcXGRpc3RcXGNodW5rLUxVVzdWNUdJLmNqcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF19