@stonecrop/schema 0.13.7 → 0.13.9

package/dist/{index-C08kwqyS.js → index-C5ANE_rn.js}

@@ -1,6 +1,18 @@
 import { z as e } from "zod";
-import { isScalarType as N, isEnumType as x, isObjectType as A, isNonNullType as C, isListType as j, isNamedType as v, buildSchema as P, buildClientSchema as U } from "graphql";
-const q = [
+import { isScalarType as j, isEnumType as N, isObjectType as T, isNonNullType as L, isListType as v, isNamedType as P, buildSchema as U, buildClientSchema as q } from "graphql";
+const R = e.object({
+  /** The table view type */
+  view: e.enum(["list", "uncounted", "list-expansion", "tree", "gantt", "tree-gantt"]).optional(),
+  /** Allow the table to use the full width of its container */
+  fullWidth: e.boolean().optional(),
+  /** Default expansion state for tree views */
+  defaultTreeExpansion: e.enum(["root", "branch", "leaf"]).optional(),
+  /** Enable dependency graph connections for Gantt views */
+  dependencyGraph: e.boolean().optional()
+}).meta({
+  title: "TableViewConfig",
+  description: "JSON-safe view configuration for table fields in doctype authoring"
+}), V = [
   "Data",
   // Short text, varchar
   "Text",
@@ -39,16 +51,18 @@ const q = [
   // Dropdown selection
   "PrimaryKey",
   // Primary key field — used by the middleware to identify the record's PK column
-  "Fieldset"
+  "Fieldset",
   // UI grouping container — no DB column; children are flat columns
-], R = e.string().min(1).meta({
+  "Display"
+  // Computed/read-only field — no DB column; excluded from SQL SELECT
+], J = e.string().min(1).meta({
   title: "StonecropFieldType",
   description: "Semantic field types for Stonecrop doctypes, consistent across forms and tables"
 });
 function Q(t) {
-  return q.includes(t);
+  return V.includes(t);
 }
-const J = {
+const W = {
   // Text
   Data: { component: "ATextInput", fieldtype: "Data" },
   Text: { component: "ATextInput", fieldtype: "Text" },
@@ -77,16 +91,17 @@ const J = {
   Select: { component: "ADropdown", fieldtype: "Select" },
   // Identity — PK fields are typically hidden; no interactive component is needed
   PrimaryKey: { component: "ATextInput", fieldtype: "PrimaryKey" },
-  // Layout — UI grouping containers with no backing DB column
-  Fieldset: { component: "AFieldset", fieldtype: "Fieldset" }
+  // Layout — UI grouping containers and computed fields with no backing DB column
+  Fieldset: { component: "AFieldset", fieldtype: "Fieldset" },
+  Display: { component: "ATextInput", fieldtype: "Display" }
 };
-function W(t) {
-  return J[t]?.component ?? "ATextInput";
+function z(t) {
+  return W[t]?.component ?? "ATextInput";
 }
-function Te(t) {
-  return Q(t) ? W(t) : "ATextInput";
+function Se(t) {
+  return Q(t) ? z(t) : "ATextInput";
 }
-const z = e.union([
+const B = e.union([
   e.string(),
   // Link/Doctype target: "customer"
   e.array(e.string()),
@@ -96,82 +111,58 @@ const z = e.union([
 ]).meta({
   title: "FieldOptions",
   description: "Field options - flexible bag for type-specific configuration"
-}), B = e.looseObject({
+}), $ = e.looseObject({
   /** Error message to display when validation fails */
   errorMessage: e.string()
 }).meta({
   title: "FieldValidation",
   description: "Validation configuration for form fields"
-}), F = e.object({
-  // === CORE (required) ===
-  /** Unique identifier for the field within its doctype */
-  fieldname: e.string().min(1),
-  /** Semantic field type - determines behavior and default component */
-  fieldtype: R,
-  // === COMPONENT (optional - derived from fieldtype when not specified) ===
-  /** Vue component to render this field. If not specified, derived from TYPE_MAP */
-  component: e.string().optional(),
-  // === DISPLAY ===
-  /** Human-readable label for the field */
-  label: e.string().optional(),
-  /** Width of the field (CSS value, e.g., "40ch", "200px") */
-  width: e.string().optional(),
-  /** Text alignment within the field */
-  align: e.enum(["left", "center", "right", "start", "end"]).optional(),
-  // === BEHAVIOR ===
-  /** Whether the field is required */
-  required: e.boolean().optional(),
-  /** Whether the field is read-only */
-  readOnly: e.boolean().optional(),
-  /** Whether the field is editable (for table cells) */
-  edit: e.boolean().optional(),
-  /** Whether the field is hidden from the UI */
-  hidden: e.boolean().optional(),
-  // === VALUE ===
-  /** Current value of the field */
-  value: e.unknown().optional(),
-  /** Default value for new records */
-  default: e.unknown().optional(),
-  // === TYPE-SPECIFIC ===
-  /**
-   * Type-specific options:
-   * - Link: target doctype slug ("customer")
-   * - Doctype: child doctype slug ("sales-order-item")
-   * - Select: choices array (["Draft", "Submitted"])
-   * - Decimal: \{ precision, scale \}
-   * - Code: \{ language \}
-   */
-  options: z.optional(),
-  /**
-   * Cardinality for Doctype fields:
-   * - 'one': exactly 1 (default)
-   * - 'atMostOne': 0 or 1
-   * - 'noneOrMany': 0 or more
-   * - 'atLeastOne': 1 or more
-   */
-  cardinality: e.enum(["one", "atMostOne", "noneOrMany", "atLeastOne"]).optional(),
-  /**
-   * Input mask pattern. Accepts either a plain mask string or a stringified
-   * arrow function that receives `locale` and returns a mask string.
-   *
-   * Plain pattern: `"##/##/####"`
-   *
-   * Function pattern: `"(locale) => locale === 'en-US' ? '(###) ###-####' : '####-######'"`
-   */
-  mask: e.string().optional(),
-  // === VALIDATION ===
-  /** Validation configuration */
-  validation: B.optional(),
-  // === LAYOUT ===
-  /** Nested field definitions for Fieldset containers — UI grouping only, no DB column */
-  schema: e.array(e.record(e.string(), e.unknown())).optional()
-}).meta({
-  title: "FieldMeta",
-  description: "Unified field metadata - the single source of truth for field definitions, works for both forms (AForm) and tables (ATable)"
-}), $ = e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).meta({
+});
+function G() {
+  const t = e.object({
+    kind: e.literal("field"),
+    fieldname: e.string().min(1),
+    fieldtype: J,
+    component: e.string().optional(),
+    label: e.string().optional(),
+    width: e.string().optional(),
+    align: e.enum(["left", "center", "right", "start", "end"]).optional(),
+    edit: e.boolean().optional(),
+    mask: e.string().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    options: B.optional(),
+    required: e.boolean().optional(),
+    readOnly: e.boolean().optional(),
+    hidden: e.boolean().optional(),
+    default: e.unknown().optional(),
+    validation: $.optional(),
+    cardinality: e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).optional()
+  }).meta({ title: "ValueField" }), n = e.object({
+    kind: e.literal("table"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    // Validates that each column has fieldname; allows all other ColumnSchema properties
+    columns: e.array(e.object({ fieldname: e.string().min(1) }).passthrough()),
+    config: R.optional(),
+    mode: e.enum(["edit", "read", "display"]).optional()
+  }).meta({ title: "TableField" });
+  let o = e.never();
+  const a = e.object({
+    kind: e.literal("fieldset"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    collapsible: e.boolean().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    schema: e.lazy(() => o.array())
+  }).meta({ title: "FieldsetField" });
+  return o = e.discriminatedUnion("kind", [t, a, n]), { ValueFieldSchema: t, TableFieldSchema: n, FieldsetFieldSchema: a, DoctypeFieldSchema: o };
+}
+const D = G(), be = D.ValueFieldSchema, ke = D.FieldsetFieldSchema, Ie = D.TableFieldSchema, k = D.DoctypeFieldSchema, K = e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).meta({
   title: "Cardinality",
   description: "Cardinality for relationship links between doctypes"
-}), G = e.object({
+}), Y = e.object({
   /** Fetch method type */
   method: e.literal("sync"),
   /** Optional limit on number of records to fetch */
@@ -179,13 +170,13 @@ const z = e.union([
 }).meta({
   title: "SyncFetch",
   description: "Sync fetch strategy - data is fetched in the initial query"
-}), K = e.object({
+}), Z = e.object({
   /** Fetch method type */
   method: e.literal("lazy")
 }).meta({
   title: "LazyFetch",
   description: "Lazy fetch strategy - data is fetched on demand in a separate query"
-}), V = e.object({
+}), H = e.object({
   /** Fetch method type */
   method: e.literal("custom"),
   /** Serialized handler function to invoke */
@@ -193,14 +184,14 @@ const z = e.union([
 }).meta({
   title: "CustomFetch",
   description: "Custom fetch strategy - uses a custom handler function"
-}), Y = e.discriminatedUnion("method", [G, K, V]).meta({
+}), X = e.discriminatedUnion("method", [Y, Z, H]).meta({
   title: "FetchStrategy",
   description: "Fetch strategy for link data loading"
-}), Z = e.object({
+}), ee = e.object({
   /** Target doctype slug */
   target: e.string().min(1),
   /** Cardinality of the relationship */
-  cardinality: $,
+  cardinality: K,
   /** Backlink fieldname on the target doctype that points back to this link */
   backlink: e.string().optional(),
   /** Override default rendering component (AForm for 1:1, ATable for 1:many) */
@@ -208,13 +199,13 @@ const z = e.union([
   /** Fieldname of the corresponding Link field in the fields array */
   fieldname: e.string().min(1).optional(),
   /** Fetch strategy for loading nested data */
-  fetch: Y.optional(),
+  fetch: X.optional(),
   /** Whether to block workflow actions until nested data is loaded (default: true) */
   blockWorkflows: e.boolean().optional()
 }).meta({
   title: "LinkDeclaration",
   description: "Declares a relationship from one doctype to another"
-}), H = e.object({
+}), te = e.object({
   /** Display label for the action */
   label: e.string().min(1),
   /** Handler function name or path */
@@ -230,86 +221,86 @@ const z = e.union([
 }).meta({
   title: "ActionDefinition",
   description: "Action definition within a workflow"
-}), X = e.object({
+}), ne = e.object({
   /** List of workflow states */
   states: e.array(e.string()).optional(),
   /** Actions available in this workflow */
-  actions: e.record(e.string(), H).optional()
+  actions: e.record(e.string(), te).optional()
 }).meta({
   title: "WorkflowMeta",
   description: "Workflow metadata - states and actions for a doctype"
-}), L = e.object({
+}), _ = e.object({
   /** Display name of the doctype */
   name: e.string().min(1),
   /** URL-friendly slug (kebab-case) */
   slug: e.string().min(1).optional(),
   /** Field definitions (including link fields with fieldtype: 'Link') */
-  fields: e.array(F),
+  fields: e.array(k),
   /** Relationship links to other doctypes */
-  links: e.record(e.string(), Z).optional(),
+  links: e.record(e.string(), ee).optional(),
   /** Workflow configuration */
-  workflow: X.optional(),
+  workflow: ne.optional(),
   /** Parent doctype for inheritance */
   inherits: e.string().optional()
 }).meta({
   title: "DoctypeMeta",
   description: "Doctype metadata - complete definition of a doctype"
 });
-function De(t) {
-  const n = F.safeParse(t);
+function Ce(t) {
+  const n = k.safeParse(t);
   return n.success ? { success: !0, errors: [] } : {
     success: !1,
-    errors: n.error.issues.map((a) => ({
-      path: a.path,
-      message: a.message
+    errors: n.error.issues.map((o) => ({
+      path: o.path,
+      message: o.message
     }))
   };
 }
-function Se(t) {
-  const n = L.safeParse(t);
+function Le(t) {
+  const n = _.safeParse(t);
   return n.success ? { success: !0, errors: [] } : {
     success: !1,
-    errors: n.error.issues.map((a) => ({
-      path: a.path,
-      message: a.message
+    errors: n.error.issues.map((o) => ({
+      path: o.path,
+      message: o.message
     }))
   };
 }
-function ke(t) {
-  return F.parse(t);
+function _e(t) {
+  return k.parse(t);
 }
-function Fe(t) {
-  return L.parse(t);
+function we(t) {
+  return _.parse(t);
 }
-function Ie(t) {
-  return t.replace(/_([a-z])/g, (n, a) => a.toUpperCase());
+function Oe(t) {
+  return t.replace(/_([a-z])/g, (n, o) => o.toUpperCase());
 }
-function be(t) {
+function Me(t) {
   return t.replace(/[A-Z]/g, (n) => `_${n.toLowerCase()}`);
 }
-function Ce(t) {
+function Ee(t) {
   return t.split("_").map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join(" ");
 }
-function ee(t) {
+function ie(t) {
   const n = t.replace(/([A-Z])/g, " $1").trim();
   return n.charAt(0).toUpperCase() + n.slice(1);
 }
-function te(t) {
+function oe(t) {
   return t.split(/[-_\s]+/).map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join("");
 }
 function h(t) {
   return t.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
 }
-function Le(t) {
+function xe(t) {
   return t.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
 }
-const ne = {
+const ae = {
   String: { component: "ATextInput", fieldtype: "Data" },
   Int: { component: "ANumericInput", fieldtype: "Int" },
   Float: { component: "ANumericInput", fieldtype: "Float" },
   Boolean: { component: "ACheckbox", fieldtype: "Check" },
   ID: { component: "ATextInput", fieldtype: "Data" }
-}, ie = {
+}, re = {
   // Arbitrary precision / large numbers
   BigFloat: { component: "ADecimalInput", fieldtype: "Decimal" },
   BigDecimal: { component: "ADecimalInput", fieldtype: "Decimal" },
@@ -329,20 +320,20 @@ const ne = {
   JSON: { component: "ACodeEditor", fieldtype: "JSON" },
   JSONObject: { component: "ACodeEditor", fieldtype: "JSON" },
   JsonNode: { component: "ACodeEditor", fieldtype: "JSON" }
-}, oe = /* @__PURE__ */ new Set(["Cursor"]);
-function ae(t) {
-  const n = { ...ie };
-  for (const [a, o] of Object.entries(ne))
-    n[a] = o;
+}, le = /* @__PURE__ */ new Set(["Cursor"]);
+function se(t) {
+  const n = { ...re };
+  for (const [o, a] of Object.entries(ae))
+    n[o] = a;
   if (t)
-    for (const [a, o] of Object.entries(t))
-      n[a] = {
-        component: o.component ?? "ATextInput",
-        fieldtype: o.fieldtype ?? "Data"
+    for (const [o, a] of Object.entries(t))
+      n[o] = {
+        component: a.component ?? "ATextInput",
+        fieldtype: a.fieldtype ?? "Data"
       };
   return n;
 }
-const re = [
+const ce = [
   "Connection",
   "Edge",
   "Input",
@@ -358,145 +349,153 @@ const re = [
   "InsertResponse",
   "UpdateResponse",
   "MutationResponse"
-], se = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
-function ce(t, n) {
-  if (t.startsWith("__") || se.has(t) || t === "Node")
+], pe = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
+function de(t, n) {
+  if (t.startsWith("__") || pe.has(t) || t === "Node")
     return !1;
-  for (const o of re)
-    if (t.endsWith(o))
+  for (const a of ce)
+    if (t.endsWith(a))
       return !1;
-  const a = n.getFields();
-  return Object.keys(a).length !== 0;
+  const o = n.getFields();
+  return Object.keys(o).length !== 0;
 }
-const le = /* @__PURE__ */ new Set(["nodeId", "__typename", "clientMutationId"]);
-function pe(t, n, a) {
-  return !le.has(t);
+const me = /* @__PURE__ */ new Set(["nodeId", "__typename", "clientMutationId"]);
+function ue(t, n, o) {
+  return !me.has(t);
 }
-function k(t) {
-  let n = !1, a = !1, o = t;
-  if (C(o) && (n = !0, o = o.ofType), j(o) && (a = !0, o = o.ofType, C(o) && (o = o.ofType)), !v(o))
-    throw new Error(`Expected a named GraphQL type, got: ${String(o)}`);
-  return { namedType: o, required: n, isList: a };
+function b(t) {
+  let n = !1, o = !1, a = t;
+  if (L(a) && (n = !0, a = a.ofType), v(a) && (o = !0, a = a.ofType, L(a) && (a = a.ofType)), !P(a))
+    throw new Error(`Expected a named GraphQL type, got: ${String(a)}`);
+  return { namedType: a, required: n, isList: o };
 }
-function de(t) {
-  const a = t.getFields().edges;
-  if (!a) return;
-  const { namedType: o, isList: r } = k(a.type);
-  if (!r || !A(o)) return;
-  const d = o.getFields().node;
+function fe(t) {
+  const o = t.getFields().edges;
+  if (!o) return;
+  const { namedType: a, isList: r } = b(o.type);
+  if (!r || !T(a)) return;
+  const d = a.getFields().node;
   if (!d) return;
-  const { namedType: u } = k(d.type);
-  if (A(u))
-    return u.name;
+  const { namedType: m } = b(d.type);
+  if (T(m))
+    return m.name;
 }
-function ue(t, n, a, o = {}) {
-  const { namedType: r, required: y, isList: d } = k(n.type), u = ae(o.customScalars), i = {
+function ye(t, n, o, a = {}) {
+  const { namedType: r, required: y, isList: d } = b(n.type), m = se(a.customScalars), i = {
+    kind: "field",
     fieldname: t,
-    label: ee(t),
+    label: ie(t),
     component: "ATextInput",
     fieldtype: "Data"
   };
-  if (y && (i.required = !0), N(r)) {
-    if (oe.has(r.name))
-      return i._unmapped = !0, o.includeUnmappedMeta && (i._graphqlType = r.name), i;
+  if (y && (i.required = !0), j(r)) {
+    if (le.has(r.name))
+      return i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i;
     if (r.name === "ID") {
-      const m = te(t);
-      if (a.has(m))
-        return i.component = "ALink", i.fieldtype = "Link", i.options = h(m), i;
+      const u = oe(t);
+      if (o.has(u))
+        return i.component = "ALink", i.fieldtype = "Link", i.options = h(u), i;
     }
-    const c = u[r.name];
-    return c ? (i.component = c.component, i.fieldtype = c.fieldtype) : (i._unmapped = !0, o.includeUnmappedMeta && (i._graphqlType = r.name)), i;
+    const s = m[r.name];
+    return s ? (i.component = s.component, i.fieldtype = s.fieldtype) : (i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name)), i;
   }
-  if (x(r))
-    return i.component = "ADropdown", i.fieldtype = "Select", i.options = r.getValues().map((c) => c.name), i;
-  if (A(r)) {
-    if (!d && a.has(r.name))
+  if (N(r))
+    return i.component = "ADropdown", i.fieldtype = "Select", i.options = r.getValues().map((s) => s.name), i;
+  if (T(r)) {
+    if (!d && o.has(r.name))
       return i.component = "ALink", i.fieldtype = "Link", i.options = h(r.name), i;
-    const c = de(r);
-    return c && a.has(c) ? (i.component = "ATable", i._isLink = !0, i.options = h(c), i.cardinality = "noneOrMany", delete i.fieldtype, i) : d && a.has(r.name) ? (i.component = "ATable", i._isLink = !0, i.options = h(r.name), i.cardinality = "noneOrMany", delete i.fieldtype, i) : (i._unmapped = !0, o.includeUnmappedMeta && (i._graphqlType = r.name), i);
+    const s = fe(r);
+    return s && o.has(s) ? (i.component = "ATable", i._isLink = !0, i.options = h(s), i.cardinality = "noneOrMany", delete i.fieldtype, i) : d && o.has(r.name) ? (i.component = "ATable", i._isLink = !0, i.options = h(r.name), i.cardinality = "noneOrMany", delete i.fieldtype, i) : (i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i);
   }
-  return i._unmapped = !0, o.includeUnmappedMeta && (i._graphqlType = r.name), i;
+  return i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i;
 }
-function _e(t, n = {}) {
-  const a = me(t), o = a.getTypeMap(), r = /* @__PURE__ */ new Set(), y = a.getQueryType(), d = a.getMutationType(), u = a.getSubscriptionType();
-  y && r.add(y.name), d && r.add(d.name), u && r.add(u.name);
-  const i = n.isEntityType ?? ce, c = /* @__PURE__ */ new Set();
-  for (const [l, p] of Object.entries(o))
-    A(p) && (r.has(l) || i(l, p) && c.add(l));
-  let m = c;
+function je(t, n = {}) {
+  const o = ge(t), a = o.getTypeMap(), r = /* @__PURE__ */ new Set(), y = o.getQueryType(), d = o.getMutationType(), m = o.getSubscriptionType();
+  y && r.add(y.name), d && r.add(d.name), m && r.add(m.name);
+  const i = n.isEntityType ?? de, s = /* @__PURE__ */ new Set();
+  for (const [c, p] of Object.entries(a))
+    T(p) && (r.has(c) || i(c, p) && s.add(c));
+  let u = s;
   if (n.include) {
-    const l = new Set(n.include);
-    m = new Set([...c].filter((p) => l.has(p)));
+    const c = new Set(n.include);
+    u = new Set([...s].filter((p) => c.has(p)));
   }
   if (n.exclude) {
-    const l = new Set(n.exclude);
-    m = new Set([...m].filter((p) => !l.has(p)));
+    const c = new Set(n.exclude);
+    u = new Set([...u].filter((p) => !c.has(p)));
   }
-  const _ = n.isEntityField ?? pe, I = [];
-  for (const l of m) {
-    const p = o[l];
-    if (!A(p)) continue;
-    const w = p.getFields(), b = n.typeOverrides?.[l], O = Object.entries(w).filter(([s, g]) => _(s, g, p)).map(([s, g]) => {
+  const w = n.isEntityField ?? ue, I = [];
+  for (const c of u) {
+    const p = a[c];
+    if (!T(p)) continue;
+    const O = p.getFields(), C = n.typeOverrides?.[c], M = Object.entries(O).filter(([l, g]) => w(l, g, p)).map(([l, g]) => {
       if (n.classifyField) {
-        const f = n.classifyField(s, g, p);
+        const f = n.classifyField(l, g, p);
         if (f != null)
           return {
-            fieldname: s,
-            label: f.label ?? s,
+            kind: "field",
+            fieldname: l,
+            label: f.label ?? l,
             component: f.component ?? "ATextInput",
             fieldtype: f.fieldtype ?? "Data",
             ...f
           };
       }
-      const T = ue(s, g, c, n);
-      return b?.[s] ? { ...T, ...b[s] } : T;
-    }), D = {}, M = O.filter((s) => s._isLink && typeof s.options == "string" && s.cardinality ? (D[s.fieldname] = {
-      target: s.options,
-      cardinality: s.cardinality
-    }, !1) : !0).map((s) => {
+      const F = ye(l, g, s, n);
+      return C?.[l] ? Object.assign(F, C[l]) : F;
+    }), A = {}, E = M.filter((l) => l._isLink && typeof l.options == "string" && l.cardinality ? (A[l.fieldname] = {
+      target: l.options,
+      cardinality: l.cardinality
+    }, !1) : !0).map((l) => {
       if (!n.includeUnmappedMeta) {
-        const { _graphqlType: f, _unmapped: ye, _isLink: ge, ...E } = s;
-        return E;
+        const { _graphqlType: f, _unmapped: Te, _isLink: Fe, ...x } = l;
+        return x;
       }
-      const { _isLink: g, ...T } = s;
-      return T;
+      const { _isLink: g, ...F } = l;
+      return F;
     }), S = {
-      name: l,
-      slug: h(l),
-      fields: M
+      name: c,
+      slug: h(c),
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- safe: heuristics always set a fieldtype default ('Data'); the optional fieldtype on GraphQLConversionFieldMeta is for intermediate processing, not because output fields lack fieldtype
+      fields: E
     };
-    Object.keys(D).length > 0 && (S.links = D), n.includeUnmappedMeta && (S._graphqlTypeName = l), I.push(S);
+    Object.keys(A).length > 0 && (S.links = A), n.includeUnmappedMeta && (S._graphqlTypeName = c), I.push(S);
   }
   return I;
 }
-function me(t) {
-  return typeof t == "string" ? P(t) : U(t);
+function ge(t) {
+  return typeof t == "string" ? U(t) : q(t);
 }
 export {
-  q as B,
-  ne as G,
-  oe as I,
-  R as S,
-  J as T,
-  ie as W,
-  be as a,
-  ae as b,
-  ee as c,
-  ue as d,
-  _e as e,
-  pe as f,
-  ce as g,
-  W as h,
-  Q as i,
-  ke as j,
-  Le as k,
-  Ce as l,
-  h as m,
-  De as n,
-  Fe as p,
-  Te as r,
-  Ie as s,
-  te as t,
-  Se as v
+  V as B,
+  k as D,
+  ke as F,
+  ae as G,
+  le as I,
+  J as S,
+  W as T,
+  be as V,
+  re as W,
+  Ie as a,
+  R as b,
+  se as c,
+  ie as d,
+  Me as e,
+  ye as f,
+  je as g,
+  ue as h,
+  de as i,
+  z as j,
+  Q as k,
+  _e as l,
+  xe as m,
+  Ee as n,
+  h as o,
+  we as p,
+  Ce as q,
+  Se as r,
+  Oe as s,
+  oe as t,
+  Le as v
 };
-//# sourceMappingURL=index-C08kwqyS.js.map
+//# sourceMappingURL=index-C5ANE_rn.js.map