orynn 0.1.0

package/dist/index.cjs

@@ -0,0 +1,823 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+
+// src/internal/cx.ts
+function cx(...names) {
+  return names.filter(Boolean).join(" ");
+}
+function toMessages(error) {
+  if (error == null) return [];
+  return (Array.isArray(error) ? error : [error]).filter((m) => Boolean(m));
+}
+function joinIds(...ids) {
+  const list = ids.filter((id) => Boolean(id));
+  return list.length > 0 ? list.join(" ") : void 0;
+}
+function Field(props) {
+  const { label, description, error, required, disabled, className, children } = props;
+  const reactId = react.useId();
+  const id = props.id ?? reactId;
+  const messages = toMessages(error);
+  const invalid = messages.length > 0;
+  const descriptionId = description != null ? `${id}-description` : void 0;
+  const errorId = invalid ? `${id}-error` : void 0;
+  const describedById = joinIds(descriptionId, errorId);
+  const ctx = { id, describedById, invalid, required, disabled };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cx("orynn-field", className),
+      "data-invalid": invalid || void 0,
+      "data-disabled": disabled || void 0,
+      "data-required": required || void 0,
+      children: [
+        label != null && /* @__PURE__ */ jsxRuntime.jsx("label", { className: "orynn-field__label", htmlFor: id, children: label }),
+        description != null && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "orynn-field__description", id: descriptionId, children: description }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "orynn-field__control", children: typeof children === "function" ? children(ctx) : children }),
+        invalid && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "orynn-field__error", id: errorId, role: "alert", children: messages.length === 1 ? messages[0] : messages.map((m) => /* @__PURE__ */ jsxRuntime.jsx("span", { children: m }, m)) })
+      ]
+    }
+  );
+}
+var Dropdown = /* @__PURE__ */ react.forwardRef(
+  function Dropdown2(props, ref) {
+    const {
+      label,
+      description,
+      error,
+      className,
+      options,
+      value,
+      onChange,
+      placeholder,
+      id,
+      required,
+      disabled,
+      onBlur,
+      onFocus,
+      ...rest
+    } = props;
+    const handleChange = react.useCallback(
+      (event) => onChange?.(event.target.value, event),
+      [onChange]
+    );
+    const controlled = value !== void 0;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Field,
+      {
+        label,
+        description,
+        error,
+        required,
+        disabled,
+        id,
+        className,
+        children: ({ id: fieldId, describedById, invalid }) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "select",
+          {
+            ...rest,
+            ref,
+            id: fieldId,
+            className: "orynn-dropdown",
+            required,
+            disabled,
+            "aria-invalid": invalid || void 0,
+            "aria-describedby": describedById,
+            ...controlled ? { value } : {},
+            onChange: handleChange,
+            onBlur,
+            onFocus,
+            children: [
+              placeholder != null && /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: required, children: placeholder }),
+              options.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, disabled: option.disabled, children: option.label }, option.value))
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+var Input = /* @__PURE__ */ react.forwardRef(
+  function Input2(props, ref) {
+    const {
+      label,
+      description,
+      error,
+      className,
+      value,
+      onChange,
+      type = "text",
+      id,
+      required,
+      disabled,
+      readOnly,
+      onBlur,
+      onFocus,
+      ...rest
+    } = props;
+    const handleChange = react.useCallback(
+      (event) => onChange?.(event.target.value, event),
+      [onChange]
+    );
+    const controlled = value !== void 0;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Field,
+      {
+        label,
+        description,
+        error,
+        required,
+        disabled,
+        id,
+        className,
+        children: ({ id: fieldId, describedById, invalid }) => /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            ...rest,
+            ref,
+            id: fieldId,
+            className: "orynn-input",
+            type,
+            required,
+            disabled,
+            readOnly,
+            "aria-invalid": invalid || void 0,
+            "aria-describedby": describedById,
+            ...controlled ? { value } : {},
+            onChange: handleChange,
+            onBlur,
+            onFocus
+          }
+        )
+      }
+    );
+  }
+);
+
+// src/internal/dev.ts
+var __DEV__ = typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+function invariant(condition, message) {
+  if (condition) return;
+  if (__DEV__) {
+    throw new Error(`[orynn] ${message}`);
+  }
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (!__DEV__ || warned.has(message)) return;
+  warned.add(message);
+  console.warn(`[orynn] ${message}`);
+}
+
+// src/core/registry/registry.ts
+var _entries;
+var Registry = class {
+  constructor() {
+    __privateAdd(this, _entries, /* @__PURE__ */ new Map());
+  }
+  register(type, registration) {
+    if (__DEV__ && __privateGet(this, _entries).has(type)) {
+      warnOnce(`Field type "${type}" is being re-registered; the previous definition is replaced.`);
+    }
+    __privateGet(this, _entries).set(type, registration);
+  }
+  get(type) {
+    return __privateGet(this, _entries).get(type);
+  }
+  has(type) {
+    return __privateGet(this, _entries).has(type);
+  }
+  types() {
+    return [...__privateGet(this, _entries).keys()];
+  }
+};
+_entries = new WeakMap();
+function createRegistry() {
+  return new Registry();
+}
+var defaultRegistry = /* @__PURE__ */ createRegistry();
+function registerField(type, registration) {
+  defaultRegistry.register(type, registration);
+}
+
+// src/layout/resolve-columns.ts
+var DEFAULT_COLUMNS = { desktop: 3, tablet: 2, mobile: 1 };
+var clampCount = (n, fallback) => typeof n === "number" && Number.isFinite(n) && n >= 1 ? Math.floor(n) : fallback;
+function resolveColumns(partial) {
+  return {
+    desktop: clampCount(partial?.desktop, DEFAULT_COLUMNS.desktop),
+    tablet: clampCount(partial?.tablet, DEFAULT_COLUMNS.tablet),
+    mobile: clampCount(partial?.mobile, DEFAULT_COLUMNS.mobile)
+  };
+}
+function clampSpan(span, columnCount) {
+  const n = clampCount(span, 1);
+  return Math.min(n, Math.max(columnCount, 1));
+}
+
+// src/core/config/normalize.ts
+function normalizeGap(gap) {
+  if (gap == null) return void 0;
+  return typeof gap === "number" ? `${gap}px` : gap;
+}
+function normalizeConfig(config, registry2) {
+  invariant(
+    config != null && typeof config === "object" && Array.isArray(config.fields),
+    "`config` must be an object with a `fields` array."
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of config.fields) {
+    invariant(
+      field != null && typeof field === "object",
+      "Every entry in `config.fields` must be an object."
+    );
+    invariant(
+      typeof field.name === "string" && field.name.length > 0,
+      "Every field needs a non-empty string `name`."
+    );
+    invariant(!seen.has(field.name), `Duplicate field name "${field.name}" in config.fields.`);
+    seen.add(field.name);
+    invariant(
+      typeof field.type === "string" && field.type.length > 0,
+      `Field "${field.name}" is missing a "type".`
+    );
+    if (registry2) {
+      invariant(
+        registry2.has(field.type),
+        `Unknown field type "${field.type}" on field "${field.name}". Registered types: ${registry2.types().join(", ") || "(none)"}.`
+      );
+      const typeError = registry2.get(field.type)?.validateConfig?.(field);
+      invariant(typeError == null, `Field "${field.name}" (${field.type}): ${typeError}`);
+    }
+  }
+  return {
+    fields: config.fields,
+    columns: resolveColumns(config.columns),
+    gap: normalizeGap(config.gap),
+    legend: config.legend,
+    id: config.id
+  };
+}
+
+// src/core/validation/messages.ts
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var defaultMessages = {
+  required: ({ label }) => `${label} is required`,
+  minLength: ({ param, label }) => `${label} must be at least ${plural(param, "character")}`,
+  maxLength: ({ param, label }) => `${label} must be at most ${plural(param, "character")}`
+};
+var FALLBACK_LABEL = "This field";
+function resolveMessage(token, param, label, overrides) {
+  const override = overrides?.[token];
+  if (override != null) return override;
+  const formatter = defaultMessages[token];
+  if (formatter) return formatter({ param, label: label ?? FALLBACK_LABEL });
+  return token;
+}
+
+// src/core/validation/rules.ts
+var isEmpty = (value) => value == null || value === "" || Array.isArray(value) && value.length === 0;
+var asLength = (value) => typeof value === "string" || Array.isArray(value) ? value.length : String(value ?? "").length;
+var builtInRules = {
+  required: (value, param) => {
+    if (param === false) return null;
+    return isEmpty(value) ? "required" : null;
+  },
+  minLength: (value, param) => {
+    if (typeof param !== "number" || isEmpty(value)) return null;
+    return asLength(value) < param ? "minLength" : null;
+  },
+  maxLength: (value, param) => {
+    if (typeof param !== "number" || isEmpty(value)) return null;
+    return asLength(value) > param ? "maxLength" : null;
+  }
+};
+var registry = new Map(Object.entries(builtInRules));
+function registerRule(name, fn) {
+  registry.set(name, fn);
+}
+function getRule(name) {
+  return registry.get(name);
+}
+
+// src/core/validation/resolver.ts
+function createRuleResolver() {
+  return (values, config) => {
+    const result = {};
+    for (const field of config.fields) {
+      const validation = field.validation;
+      if (!validation) continue;
+      const value = values[field.name];
+      const errors = [];
+      for (const key of Object.keys(validation)) {
+        if (key === "messages") continue;
+        const param = validation[key];
+        if (param === void 0 || param === false) continue;
+        const rule = getRule(key);
+        if (!rule) {
+          if (__DEV__) {
+            warnOnce(`No validator registered for rule "${key}" (field "${field.name}").`);
+          }
+          continue;
+        }
+        const token = rule(value, param, values);
+        if (token == null) continue;
+        errors.push({
+          rule: key,
+          message: resolveMessage(token, param, field.label, validation.messages)
+        });
+      }
+      if (errors.length > 0) result[field.name] = errors;
+    }
+    return result;
+  };
+}
+var defaultResolver = /* @__PURE__ */ createRuleResolver();
+
+// src/core/state/reducer.ts
+var initialMeta = {
+  touched: {},
+  errors: {},
+  validating: false,
+  everValidated: false
+};
+function metaReducer(state, action) {
+  switch (action.type) {
+    case "touch": {
+      if (state.touched[action.name]) return state;
+      return { ...state, touched: { ...state.touched, [action.name]: true } };
+    }
+    case "touchAll": {
+      const touched = { ...state.touched };
+      for (const name of action.names) touched[name] = true;
+      return { ...state, touched };
+    }
+    case "validation:start":
+      return { ...state, validating: true };
+    case "validation:field": {
+      const errors = { ...state.errors };
+      if (action.errors.length > 0) errors[action.name] = action.errors;
+      else delete errors[action.name];
+      return { ...state, errors, validating: false, everValidated: true };
+    }
+    case "validation:all":
+      return { ...state, errors: action.result, validating: false, everValidated: true };
+    case "reset":
+      return { ...initialMeta };
+    default:
+      return state;
+  }
+}
+function deriveStatus(meta) {
+  if (meta.validating) return "validating";
+  if (!meta.everValidated) return "idle";
+  return Object.keys(meta.errors).length > 0 ? "invalid" : "valid";
+}
+function computeDirty(values, initial) {
+  const dirty = {};
+  for (const key of Object.keys(values)) {
+    if (!Object.is(values[key], initial[key])) dirty[key] = true;
+  }
+  return dirty;
+}
+function useLatestRef(value) {
+  const ref = react.useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+// src/core/state/use-controllable-state.ts
+function useControllableState({
+  value,
+  defaultValue,
+  onChange
+}) {
+  const isControlled = value !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultValue);
+  const current = isControlled ? value : uncontrolled;
+  const currentRef = useLatestRef(current);
+  const onChangeRef = useLatestRef(onChange);
+  const isControlledRef = useLatestRef(isControlled);
+  const setValue = react.useCallback((next) => {
+    const resolved = typeof next === "function" ? next(currentRef.current) : next;
+    if (Object.is(resolved, currentRef.current)) return;
+    if (!isControlledRef.current) setUncontrolled(resolved);
+    onChangeRef.current?.(resolved);
+  }, []);
+  return [current, setValue];
+}
+
+// src/core/state/use-fieldset-state.ts
+var NO_ERRORS = Object.freeze([]);
+function computeInitialValues(config, registry2, provided) {
+  const out = {};
+  for (const field of config.fields) {
+    if (provided && Object.prototype.hasOwnProperty.call(provided, field.name)) {
+      out[field.name] = provided[field.name];
+    } else if (field.defaultValue !== void 0) {
+      out[field.name] = field.defaultValue;
+    } else {
+      out[field.name] = registry2?.get(field.type)?.defaultValue ?? "";
+    }
+  }
+  return out;
+}
+function useFieldsetState(config, options = {}) {
+  const {
+    value,
+    defaultValue,
+    onChange,
+    onValidationChange,
+    resolver = defaultResolver,
+    registry: registry2,
+    validateOn = "blur"
+  } = options;
+  const normalized = react.useMemo(() => normalizeConfig(config, registry2), [config, registry2]);
+  const initialRef = react.useRef(null);
+  if (initialRef.current === null) {
+    initialRef.current = computeInitialValues(
+      normalized,
+      registry2,
+      value ?? defaultValue
+    );
+  }
+  const [rawValues, setRawValues] = useControllableState({
+    value,
+    defaultValue: initialRef.current,
+    onChange
+  });
+  const values = react.useMemo(() => ({ ...initialRef.current, ...rawValues }), [rawValues]);
+  const [meta, dispatch] = react.useReducer(metaReducer, initialMeta);
+  const valuesRef = useLatestRef(values);
+  const resolverRef = useLatestRef(resolver);
+  const configRef = useLatestRef(config);
+  const normalizedRef = useLatestRef(normalized);
+  const registryRef = useLatestRef(registry2);
+  const validateOnRef = useLatestRef(validateOn);
+  const onValidationChangeRef = useLatestRef(onValidationChange);
+  const runIdRef = react.useRef(0);
+  const runValidation = react.useCallback(async (scope) => {
+    const runId = ++runIdRef.current;
+    const input = scope.values ?? valuesRef.current;
+    dispatch({ type: "validation:start" });
+    const result = await resolverRef.current(input, configRef.current, {
+      trigger: scope.trigger,
+      ...scope.field ? { changedField: scope.field } : {}
+    });
+    if (runId !== runIdRef.current) return result;
+    if (scope.field) {
+      dispatch({ type: "validation:field", name: scope.field, errors: result[scope.field] ?? [] });
+    } else {
+      dispatch({ type: "validation:all", result });
+      onValidationChangeRef.current?.(result);
+    }
+    return result;
+  }, []);
+  const setFieldValue = react.useCallback(
+    (name, next) => {
+      setRawValues((prev) => ({ ...prev, [name]: next }));
+      if (validateOnRef.current === "change") {
+        void runValidation({
+          field: name,
+          trigger: "change",
+          values: { ...valuesRef.current, [name]: next }
+        });
+      }
+    },
+    [setRawValues, runValidation]
+  );
+  const setValues = react.useCallback((next) => setRawValues(next), [setRawValues]);
+  const markTouched = react.useCallback(
+    (name) => {
+      dispatch({ type: "touch", name });
+      if (validateOnRef.current === "blur") {
+        void runValidation({ field: name, trigger: "blur" });
+      }
+    },
+    [runValidation]
+  );
+  const validate = react.useCallback(() => runValidation({ trigger: "submit" }), [runValidation]);
+  const handleSubmit = react.useCallback(
+    (onValid, onInvalid) => async (event) => {
+      event?.preventDefault?.();
+      dispatch({
+        type: "touchAll",
+        names: normalizedRef.current.fields.map((f) => f.name)
+      });
+      const result = await runValidation({ trigger: "submit" });
+      if (Object.keys(result).length === 0) onValid(valuesRef.current);
+      else onInvalid?.(result);
+    },
+    [runValidation]
+  );
+  const reset = react.useCallback(
+    (next) => {
+      const fresh = computeInitialValues(
+        normalizedRef.current,
+        registryRef.current,
+        next
+      );
+      initialRef.current = fresh;
+      setRawValues(fresh);
+      dispatch({ type: "reset" });
+      runIdRef.current++;
+    },
+    [setRawValues]
+  );
+  const handlerCacheRef = react.useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const getHandlers = react.useCallback(
+    (name) => {
+      const cache = handlerCacheRef.current;
+      let entry = cache.get(name);
+      if (!entry) {
+        entry = {
+          setValue: (v) => setFieldValue(name, v),
+          markTouched: () => markTouched(name)
+        };
+        cache.set(name, entry);
+      }
+      return entry;
+    },
+    [setFieldValue, markTouched]
+  );
+  const dirty = react.useMemo(() => computeDirty(values, initialRef.current ?? {}), [values]);
+  const status = deriveStatus(meta);
+  const isValid = Object.keys(meta.errors).length === 0;
+  const getFieldProps = react.useCallback(
+    (name) => {
+      const handlers = getHandlers(name);
+      return {
+        name,
+        value: values[name],
+        errors: meta.errors[name] ?? NO_ERRORS,
+        touched: meta.touched[name] ?? false,
+        dirty: dirty[name] ?? false,
+        setValue: handlers.setValue,
+        markTouched: handlers.markTouched
+      };
+    },
+    [values, meta.errors, meta.touched, dirty, getHandlers]
+  );
+  const state = react.useMemo(
+    () => ({
+      values,
+      touched: meta.touched,
+      dirty,
+      errors: meta.errors,
+      status
+    }),
+    [values, meta.touched, dirty, meta.errors, status]
+  );
+  return {
+    config: normalized,
+    state,
+    values,
+    errors: meta.errors,
+    touched: meta.touched,
+    dirty,
+    status,
+    isValid,
+    setFieldValue,
+    setValues,
+    reset,
+    validate,
+    handleSubmit,
+    getFieldProps
+  };
+}
+function FieldGrid({ columns, gap, className, children }) {
+  const style = {
+    "--orynn-cols-desktop": columns.desktop,
+    "--orynn-cols-tablet": columns.tablet,
+    "--orynn-cols-mobile": columns.mobile,
+    ...gap ? { "--orynn-grid-gap": gap } : {}
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cx("orynn-grid", className), style, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "orynn-grid__track", children }) });
+}
+function FieldGridItem({ span, columns, children }) {
+  if (!span) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  const style = {
+    "--orynn-span-desktop": clampSpan(span.desktop, columns.desktop),
+    "--orynn-span-tablet": clampSpan(span.tablet, columns.tablet),
+    "--orynn-span-mobile": clampSpan(span.mobile, columns.mobile)
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "orynn-grid__item", style, children });
+}
+var noop = () => {
+};
+function FieldRendererImpl({ field, registry: registry2, slice, disabled }) {
+  const registration = registry2.get(field.type);
+  invariant(
+    registration,
+    `No control registered for field type "${field.type}" (field "${field.name}").`
+  );
+  if (!registration) return null;
+  const Control = registration.component;
+  const required = field.validation?.required === true;
+  const isDisabled = disabled === true || field.disabled === true;
+  const value = registration.parseValue ? registration.parseValue(slice.value) : slice.value;
+  const messages = slice.errors.map((e) => e.message);
+  const handleChange = (next) => {
+    slice.setValue(registration.formatValue ? registration.formatValue(next) : next);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Field,
+    {
+      label: field.label,
+      description: field.description,
+      error: messages,
+      required,
+      disabled: isDisabled,
+      children: ({ id, describedById, invalid }) => /* @__PURE__ */ jsxRuntime.jsx(
+        Control,
+        {
+          id,
+          name: field.name,
+          value,
+          onChange: handleChange,
+          onBlur: slice.markTouched,
+          onFocus: noop,
+          disabled: isDisabled,
+          readOnly: field.readOnly === true,
+          required,
+          invalid,
+          describedById,
+          config: field
+        }
+      )
+    }
+  );
+}
+var FieldRenderer = /* @__PURE__ */ react.memo(
+  FieldRendererImpl,
+  (prev, next) => prev.field === next.field && prev.registry === next.registry && prev.disabled === next.disabled && prev.slice.value === next.slice.value && prev.slice.touched === next.slice.touched && prev.slice.errors === next.slice.errors && prev.slice.setValue === next.slice.setValue && prev.slice.markTouched === next.slice.markTouched
+);
+var toStringValue = (value) => typeof value === "string" ? value : value == null ? "" : String(value);
+var InputControl = ({
+  id,
+  name,
+  value,
+  onChange,
+  onBlur,
+  onFocus,
+  disabled,
+  readOnly,
+  required,
+  invalid,
+  describedById,
+  config
+}) => {
+  const field = config;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "input",
+    {
+      id,
+      name,
+      className: "orynn-input",
+      type: field.inputType ?? "text",
+      value: toStringValue(value),
+      placeholder: field.placeholder,
+      required,
+      disabled,
+      readOnly,
+      "aria-invalid": invalid || void 0,
+      "aria-describedby": describedById,
+      onChange: (event) => onChange(event.target.value, event),
+      onBlur,
+      onFocus,
+      ...field.props
+    }
+  );
+};
+var DropdownControl = ({
+  id,
+  name,
+  value,
+  onChange,
+  onBlur,
+  onFocus,
+  disabled,
+  required,
+  invalid,
+  describedById,
+  config
+}) => {
+  const field = config;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "select",
+    {
+      id,
+      name,
+      className: "orynn-dropdown",
+      value: toStringValue(value),
+      required,
+      disabled,
+      "aria-invalid": invalid || void 0,
+      "aria-describedby": describedById,
+      onChange: (event) => onChange(event.target.value, event),
+      onBlur,
+      onFocus,
+      ...field.props,
+      children: [
+        field.placeholder != null && /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: required, children: field.placeholder }),
+        field.options.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, disabled: option.disabled, children: option.label }, option.value))
+      ]
+    }
+  );
+};
+function registerBuiltins(registry2) {
+  if (!registry2.has("input")) {
+    registry2.register("input", { component: InputControl, defaultValue: "" });
+  }
+  if (!registry2.has("dropdown")) {
+    registry2.register("dropdown", {
+      component: DropdownControl,
+      defaultValue: "",
+      validateConfig: (config) => Array.isArray(config.options) ? null : "a dropdown field requires an `options` array"
+    });
+  }
+}
+var seeded = false;
+function ensureBuiltins(defaultRegistry2) {
+  if (seeded) return;
+  seeded = true;
+  registerBuiltins(defaultRegistry2);
+}
+function Fieldset(props) {
+  const {
+    config,
+    value,
+    defaultValue,
+    onChange,
+    onValidationChange,
+    resolver,
+    registry: registry2,
+    validateOn,
+    disabled,
+    className,
+    id
+  } = props;
+  ensureBuiltins(defaultRegistry);
+  const activeRegistry = registry2 ?? defaultRegistry;
+  const options = {
+    registry: activeRegistry,
+    ...value !== void 0 ? { value } : {},
+    ...defaultValue !== void 0 ? { defaultValue } : {},
+    ...onChange ? { onChange } : {},
+    ...onValidationChange ? { onValidationChange } : {},
+    ...resolver ? { resolver } : {},
+    ...validateOn ? { validateOn } : {}
+  };
+  const fs = useFieldsetState(config, options);
+  const { columns, gap, legend, fields, id: configId } = fs.config;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "fieldset",
+    {
+      className: cx("orynn-fieldset", className),
+      id: id ?? configId,
+      disabled: disabled || void 0,
+      children: [
+        legend != null && /* @__PURE__ */ jsxRuntime.jsx("legend", { className: "orynn-fieldset__legend", children: legend }),
+        /* @__PURE__ */ jsxRuntime.jsx(FieldGrid, { columns, gap, children: fields.map((field) => /* @__PURE__ */ jsxRuntime.jsx(FieldGridItem, { span: field.layout, columns, children: /* @__PURE__ */ jsxRuntime.jsx(
+          FieldRenderer,
+          {
+            field,
+            registry: activeRegistry,
+            slice: fs.getFieldProps(field.name),
+            disabled: disabled === true
+          }
+        ) }, field.name)) })
+      ]
+    }
+  );
+}
+
+// src/types/validation.ts
+var FORM_ERROR_KEY = "$form";
+
+exports.Dropdown = Dropdown;
+exports.FORM_ERROR_KEY = FORM_ERROR_KEY;
+exports.Field = Field;
+exports.Fieldset = Fieldset;
+exports.Input = Input;
+exports.createRegistry = createRegistry;
+exports.createRuleResolver = createRuleResolver;
+exports.defaultRegistry = defaultRegistry;
+exports.defaultResolver = defaultResolver;
+exports.normalizeConfig = normalizeConfig;
+exports.registerField = registerField;
+exports.registerRule = registerRule;
+exports.useFieldsetState = useFieldsetState;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map