@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/constants.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  BASE_UI_SWIPE_IGNORE_ATTRIBUTE: () => BASE_UI_SWIPE_IGNORE_ATTRIBUTE,
+  BASE_UI_SWIPE_IGNORE_SELECTOR: () => BASE_UI_SWIPE_IGNORE_SELECTOR,
+  DISABLED_TRANSITIONS_STYLE: () => DISABLED_TRANSITIONS_STYLE,
+  DROPDOWN_COLLISION_AVOIDANCE: () => DROPDOWN_COLLISION_AVOIDANCE,
+  LEGACY_SWIPE_IGNORE_ATTRIBUTE: () => LEGACY_SWIPE_IGNORE_ATTRIBUTE,
+  LEGACY_SWIPE_IGNORE_SELECTOR: () => LEGACY_SWIPE_IGNORE_SELECTOR,
+  PATIENT_CLICK_THRESHOLD: () => PATIENT_CLICK_THRESHOLD,
+  POPUP_COLLISION_AVOIDANCE: () => POPUP_COLLISION_AVOIDANCE,
+  TYPEAHEAD_RESET_MS: () => TYPEAHEAD_RESET_MS
+});
+module.exports = __toCommonJS(constants_exports);
+const POPUP_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: "end"
+};
+const DROPDOWN_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: "none"
+};
+const DISABLED_TRANSITIONS_STYLE = { style: { transition: "none" } };
+const TYPEAHEAD_RESET_MS = 500;
+const PATIENT_CLICK_THRESHOLD = 500;
+const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
+const LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
+const BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+const LEGACY_SWIPE_IGNORE_SELECTOR = `[${LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_UI_SWIPE_IGNORE_ATTRIBUTE,
+  BASE_UI_SWIPE_IGNORE_SELECTOR,
+  DISABLED_TRANSITIONS_STYLE,
+  DROPDOWN_COLLISION_AVOIDANCE,
+  LEGACY_SWIPE_IGNORE_ATTRIBUTE,
+  LEGACY_SWIPE_IGNORE_SELECTOR,
+  PATIENT_CLICK_THRESHOLD,
+  POPUP_COLLISION_AVOIDANCE,
+  TYPEAHEAD_RESET_MS
+});

package/dist/cjs/utils/contains.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contains_exports = {};
+__export(contains_exports, {
+  contains: () => contains
+});
+module.exports = __toCommonJS(contains_exports);
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  if (parent.contains(child)) {
+    return true;
+  }
+  const rootNode = child.getRootNode?.();
+  if (rootNode && rootNode.host) {
+    let next = child;
+    while (next) {
+      if (next === parent) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  contains
+});

package/dist/cjs/utils/createChangeEventDetails.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createChangeEventDetails_exports = {};
+__export(createChangeEventDetails_exports, {
+  REASONS: () => REASONS,
+  createChangeEventDetails: () => createChangeEventDetails,
+  createGenericEventDetails: () => createGenericEventDetails
+});
+module.exports = __toCommonJS(createChangeEventDetails_exports);
+const REASONS = {
+  none: "none",
+  triggerPress: "trigger-press",
+  itemPress: "item-press",
+  keyboard: "keyboard",
+  pointer: "pointer",
+  inputChange: "input-change",
+  inputClear: "input-clear",
+  inputBlur: "input-blur",
+  inputPaste: "input-paste",
+  incrementPress: "increment-press",
+  decrementPress: "decrement-press",
+  wheel: "wheel",
+  scrub: "scrub",
+  trackPress: "track-press",
+  drag: "drag",
+  disabled: "disabled",
+  // Automatic-consistency reasons (tabs): the selected item was never valid, or went away.
+  initial: "initial",
+  missing: "missing",
+  triggerHover: "trigger-hover",
+  triggerFocus: "trigger-focus",
+  outsidePress: "outside-press",
+  closePress: "close-press",
+  focusOut: "focus-out",
+  listNavigation: "list-navigation",
+  escapeKey: "escape-key",
+  imperativeAction: "imperative-action",
+  cancelOpen: "cancel-open",
+  siblingOpen: "sibling-open"
+};
+function createChangeEventDetails(reason, event, trigger, customProperties) {
+  let canceled = false;
+  let allowPropagation = false;
+  const details = {
+    reason,
+    event: event ?? new Event("base-ui"),
+    cancel() {
+      canceled = true;
+    },
+    allowPropagation() {
+      allowPropagation = true;
+    },
+    get isCanceled() {
+      return canceled;
+    },
+    get isPropagationAllowed() {
+      return allowPropagation;
+    },
+    trigger,
+    ...customProperties
+  };
+  return details;
+}
+function createGenericEventDetails(reason, event, customProperties) {
+  return {
+    reason,
+    event: event ?? new Event("base-ui"),
+    ...customProperties
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REASONS,
+  createChangeEventDetails,
+  createGenericEventDetails
+});

package/dist/cjs/utils/dom.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dom_exports = {};
+__export(dom_exports, {
+  isElement: () => isElement,
+  isHTMLElement: () => isHTMLElement
+});
+module.exports = __toCommonJS(dom_exports);
+function isElement(value) {
+  return value != null && value instanceof Element;
+}
+function isHTMLElement(value) {
+  return value != null && value instanceof HTMLElement;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isElement,
+  isHTMLElement
+});

package/dist/cjs/utils/empty.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var empty_exports = {};
+__export(empty_exports, {
+  EMPTY_ARRAY: () => EMPTY_ARRAY,
+  EMPTY_OBJECT: () => EMPTY_OBJECT,
+  NOOP: () => import_noop.NOOP
+});
+module.exports = __toCommonJS(empty_exports);
+var import_noop = require("./noop.cjs");
+const EMPTY_OBJECT = {};
+const EMPTY_ARRAY = [];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  NOOP
+});

package/dist/cjs/utils/field/FieldItemContext.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FieldItemContext_exports = {};
+__export(FieldItemContext_exports, {
+  FieldItemContext: () => FieldItemContext,
+  useFieldItemContext: () => useFieldItemContext
+});
+module.exports = __toCommonJS(FieldItemContext_exports);
+var import_octane = require("octane");
+const FieldItemContext = (0, import_octane.createContext)({ disabled: false });
+function useFieldItemContext() {
+  return (0, import_octane.useContext)(FieldItemContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FieldItemContext,
+  useFieldItemContext
+});

package/dist/cjs/utils/field/FieldRootContext.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FieldRootContext_exports = {};
+__export(FieldRootContext_exports, {
+  DEFAULT_FIELD_ROOT_CONTEXT: () => DEFAULT_FIELD_ROOT_CONTEXT,
+  FieldRootContext: () => FieldRootContext,
+  useFieldRootContext: () => useFieldRootContext
+});
+module.exports = __toCommonJS(FieldRootContext_exports);
+var import_octane = require("octane");
+var import_noop = require("../noop.cjs");
+var import_constants = require("./constants.cjs");
+const DEFAULT_FIELD_ROOT_CONTEXT = {
+  invalid: void 0,
+  name: void 0,
+  validityData: {
+    state: import_constants.DEFAULT_VALIDITY_STATE,
+    errors: [],
+    error: "",
+    value: "",
+    initialValue: null
+  },
+  setValidityData: import_noop.NOOP,
+  disabled: void 0,
+  touched: import_constants.DEFAULT_FIELD_STATE_ATTRIBUTES.touched,
+  setTouched: import_noop.NOOP,
+  dirty: import_constants.DEFAULT_FIELD_STATE_ATTRIBUTES.dirty,
+  setDirty: import_noop.NOOP,
+  filled: import_constants.DEFAULT_FIELD_STATE_ATTRIBUTES.filled,
+  setFilled: import_noop.NOOP,
+  focused: import_constants.DEFAULT_FIELD_STATE_ATTRIBUTES.focused,
+  setFocused: import_noop.NOOP,
+  validate: () => null,
+  validationMode: "onSubmit",
+  validationDebounceTime: 0,
+  shouldValidateOnChange: () => false,
+  state: import_constants.DEFAULT_FIELD_ROOT_STATE,
+  markedDirtyRef: { current: false },
+  registerFieldControl: import_noop.NOOP,
+  validation: {
+    getValidationProps: (_disabled, props = {}) => props,
+    inputRef: { current: null },
+    registerInput: import_noop.NOOP,
+    commit: async () => {
+    },
+    change: import_noop.NOOP
+  }
+};
+const FieldRootContext = (0, import_octane.createContext)(DEFAULT_FIELD_ROOT_CONTEXT);
+function useFieldRootContext(optional = true) {
+  const context = (0, import_octane.useContext)(FieldRootContext);
+  if (context.setValidityData === import_noop.NOOP && !optional) {
+    throw new Error(
+      "Base UI: FieldRootContext is missing. Field parts must be placed within <Field.Root>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FIELD_ROOT_CONTEXT,
+  FieldRootContext,
+  useFieldRootContext
+});

package/dist/cjs/utils/field/FormContext.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FormContext_exports = {};
+__export(FormContext_exports, {
+  FormContext: () => FormContext,
+  useFormContext: () => useFormContext
+});
+module.exports = __toCommonJS(FormContext_exports);
+var import_octane = require("octane");
+var import_noop = require("../noop.cjs");
+const FormContext = (0, import_octane.createContext)({
+  formRef: { current: { fields: /* @__PURE__ */ new Map() } },
+  errors: {},
+  clearErrors: import_noop.NOOP,
+  validationMode: "onSubmit",
+  submitAttemptedRef: { current: false }
+});
+function useFormContext() {
+  return (0, import_octane.useContext)(FormContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormContext,
+  useFormContext
+});

package/dist/cjs/utils/field/LabelableContext.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LabelableContext_exports = {};
+__export(LabelableContext_exports, {
+  LabelableContext: () => LabelableContext,
+  useLabelableContext: () => useLabelableContext
+});
+module.exports = __toCommonJS(LabelableContext_exports);
+var import_octane = require("octane");
+var import_noop = require("../noop.cjs");
+const LabelableContext = (0, import_octane.createContext)({
+  controlId: void 0,
+  registerControlId: import_noop.NOOP,
+  labelId: void 0,
+  setLabelId: import_noop.NOOP,
+  messageIds: [],
+  setMessageIds: import_noop.NOOP,
+  getDescriptionProps: (externalProps) => externalProps
+});
+function useLabelableContext() {
+  return (0, import_octane.useContext)(LabelableContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LabelableContext,
+  useLabelableContext
+});

package/dist/cjs/utils/field/LabelableProvider.cjs

@@ -0,0 +1,115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LabelableProvider_exports = {};
+__export(LabelableProvider_exports, {
+  LabelableProvider: () => LabelableProvider
+});
+module.exports = __toCommonJS(LabelableProvider_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useBaseUiId = require("../useBaseUiId.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_LabelableContext = require("./LabelableContext.cjs");
+function LabelableProvider(props) {
+  const slot = (0, import_internal.S)("LabelableProvider");
+  const defaultId = (0, import_useBaseUiId.useBaseUiId)(void 0, (0, import_internal.subSlot)(slot, "default"));
+  const initialControlId = props.controlId === void 0 ? defaultId : props.controlId;
+  const [controlId, setControlIdState] = (0, import_octane.useState)(
+    initialControlId,
+    (0, import_internal.subSlot)(slot, "controlId")
+  );
+  const [labelId, setLabelId] = (0, import_octane.useState)(
+    props.labelId,
+    (0, import_internal.subSlot)(slot, "labelId")
+  );
+  const [messageIds, setMessageIds] = (0, import_octane.useState)([], (0, import_internal.subSlot)(slot, "messageIds"));
+  const registrationsRef = (0, import_useRefWithInit.useRefWithInit)(
+    () => /* @__PURE__ */ new Map(),
+    (0, import_internal.subSlot)(slot, "reg")
+  );
+  const { messageIds: parentMessageIds } = (0, import_octane.useContext)(import_LabelableContext.LabelableContext);
+  const registerControlId = (0, import_useStableCallback.useStableCallback)(
+    (source, nextId) => {
+      const registrations = registrationsRef.current;
+      if (nextId === void 0) {
+        registrations.delete(source);
+        return;
+      }
+      registrations.set(source, nextId);
+      setControlIdState((prev) => {
+        if (registrations.size === 0) {
+          return void 0;
+        }
+        let nextControlId;
+        for (const id of registrations.values()) {
+          if (prev !== void 0 && id === prev) {
+            return prev;
+          }
+          if (nextControlId === void 0) {
+            nextControlId = id;
+          }
+        }
+        return nextControlId;
+      });
+    },
+    (0, import_internal.subSlot)(slot, "registerControlId")
+  );
+  const getDescriptionProps = (0, import_octane.useCallback)(
+    (externalProps) => {
+      const ids = externalProps["aria-describedby"] ? externalProps["aria-describedby"].split(" ") : [];
+      ids.push(...parentMessageIds, ...messageIds);
+      return {
+        ...externalProps,
+        "aria-describedby": Array.from(new Set(ids)).join(" ") || void 0
+      };
+    },
+    [parentMessageIds, messageIds],
+    (0, import_internal.subSlot)(slot, "getDesc")
+  );
+  const contextValue = (0, import_octane.useMemo)(
+    () => ({
+      controlId,
+      registerControlId,
+      labelId,
+      setLabelId,
+      messageIds,
+      setMessageIds,
+      getDescriptionProps
+    }),
+    [
+      controlId,
+      registerControlId,
+      labelId,
+      setLabelId,
+      messageIds,
+      setMessageIds,
+      getDescriptionProps
+    ],
+    (0, import_internal.subSlot)(slot, "ctx")
+  );
+  return (0, import_octane.createElement)(import_LabelableContext.LabelableContext.Provider, {
+    value: contextValue,
+    children: props.children
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LabelableProvider
+});

package/dist/cjs/utils/field/constants.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_FIELD_ROOT_STATE: () => DEFAULT_FIELD_ROOT_STATE,
+  DEFAULT_FIELD_STATE_ATTRIBUTES: () => DEFAULT_FIELD_STATE_ATTRIBUTES,
+  DEFAULT_VALIDITY_STATE: () => DEFAULT_VALIDITY_STATE,
+  fieldValidityMapping: () => fieldValidityMapping
+});
+module.exports = __toCommonJS(constants_exports);
+const DEFAULT_VALIDITY_STATE = {
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valid: null,
+  valueMissing: false
+};
+const DEFAULT_FIELD_STATE_ATTRIBUTES = {
+  valid: null,
+  touched: false,
+  dirty: false,
+  filled: false,
+  focused: false
+};
+const DEFAULT_FIELD_ROOT_STATE = {
+  disabled: false,
+  ...DEFAULT_FIELD_STATE_ATTRIBUTES
+};
+const fieldValidityMapping = {
+  valid(value) {
+    if (value === null) {
+      return null;
+    }
+    if (value) {
+      return { "data-valid": "" };
+    }
+    return { "data-invalid": "" };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FIELD_ROOT_STATE,
+  DEFAULT_FIELD_STATE_ATTRIBUTES,
+  DEFAULT_VALIDITY_STATE,
+  fieldValidityMapping
+});

package/dist/cjs/utils/field/getCombinedFieldValidityData.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCombinedFieldValidityData_exports = {};
+__export(getCombinedFieldValidityData_exports, {
+  getCombinedFieldValidityData: () => getCombinedFieldValidityData
+});
+module.exports = __toCommonJS(getCombinedFieldValidityData_exports);
+function getCombinedFieldValidityData(validityData, invalid) {
+  return {
+    ...validityData,
+    state: {
+      ...validityData.state,
+      valid: !invalid && validityData.state.valid
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCombinedFieldValidityData
+});