@stonecrop/schema 0.31.0 → 0.33.0

package/dist/record-Bc0lI9Rq.js

@@ -1,61 +0,0 @@
-import { f as d } from "./flatten-C1MjkzFh.js";
-const r = {
-  ATextInput: "text",
-  ATextboxInput: "text",
-  ANumericInput: "number",
-  ACheckbox: "boolean",
-  ADate: "date",
-  ADatePicker: "date",
-  ADateSelection: "date",
-  ADateTime: "datetime",
-  ADuration: "text",
-  ADateRange: "date",
-  ADropdown: "select",
-  ASegmentedControl: "select",
-  ACodeEditor: "code",
-  AFormLink: "link",
-  AFileAttach: "attach",
-  AQuantityInput: "quantity",
-  ACurrencyInput: "currency"
-};
-function A(e) {
-  return e ? r[e] : void 0;
-}
-const c = {
-  AFormLink: "inline",
-  AForm: "expand",
-  ATable: "expand"
-};
-function s(e) {
-  return e ? c[e] : void 0;
-}
-function f(e, n) {
-  return s(e.component ?? n) === "inline" ? "inline" : e.cardinality === "noneOrMany" || e.cardinality === "atLeastOne" ? "table" : "record";
-}
-const p = [
-  .../* @__PURE__ */ new Set([...Object.keys(r), ...Object.keys(c)])
-].toSorted();
-function m(e, n) {
-  const o = new Set(
-    d(e).filter((t) => t.kind === "field" && !!t.doctype).filter((t) => s(t.component) === "inline").map((t) => t.fieldname)
-  );
-  if (o.size === 0) return n;
-  const i = new Set(e.filter((t) => t.kind === "fieldset").map((t) => t.fieldname));
-  return u(o, i, n);
-}
-function u(e, n, o) {
-  const i = { ...o };
-  for (const [t, a] of Object.entries(i))
-    a === null || typeof a != "object" || Array.isArray(a) || (e.has(t) ? "id" in a && (i[t] = a.id) : n.has(t) && (i[t] = u(e, n, a)));
-  return i;
-}
-export {
-  p as C,
-  r as a,
-  c as b,
-  A as c,
-  s as d,
-  f as r,
-  m as u
-};
-//# sourceMappingURL=record-Bc0lI9Rq.js.map

package/dist/record-Bc0lI9Rq.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"record-Bc0lI9Rq.js","sources":["../src/component-meta.ts","../src/record.ts"],"sourcesContent":["/**\n * Semantic category for a rendering component.\n *\n * `component` is the primary field axis, so the runtime consumers that need to know what a field\n * *means* (atable cell formatting / filter widgets, record-default init) derive it from here. This\n * is the single source of \"what kind of value does this component render\", keyed by the canonical\n * registered component names — each consumer maps the category to its own concern (filter widget,\n * default value, …).\n *\n * @public\n */\nexport type ComponentCategory =\n\t'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'code' | 'link' | 'attach' | 'quantity' | 'currency'\n\n/**\n * Canonical component → semantic category. Only the components Stonecrop ships with appear here;\n * custom/unknown component names have no category and consumers fall back to their default.\n * @public\n */\nexport const COMPONENT_CATEGORY: Record<string, ComponentCategory> = {\n\tATextInput: 'text',\n\tATextboxInput: 'text',\n\tANumericInput: 'number',\n\tACheckbox: 'boolean',\n\tADate: 'date',\n\tADatePicker: 'date',\n\tADateSelection: 'date',\n\tADateTime: 'datetime',\n\tADuration: 'text',\n\tADateRange: 'date',\n\tADropdown: 'select',\n\tASegmentedControl: 'select',\n\tACodeEditor: 'code',\n\tAFormLink: 'link',\n\tAFileAttach: 'attach',\n\tAQuantityInput: 'quantity',\n\tACurrencyInput: 'currency',\n}\n\n/**\n * Resolve a component's semantic category, or `undefined` for an unknown (custom) component —\n * callers treat that as \"no opinion\" and use their own default.\n * @public\n */\nexport function componentCategory(component?: string): ComponentCategory | undefined {\n\treturn component ? COMPONENT_CATEGORY[component] : undefined\n}\n\n/**\n * Whether a link component expands its target doctype, or renders the link inline.\n *\n * This is the *only* axis the component decides. It deliberately does not choose between an\n * embedded record and an embedded table: `cardinality` states whether the value is a scalar or\n * an array, which is a fact about the data rather than a rendering preference, so a component\n * must not be able to override it (an `AForm` over a `noneOrMany` link would be handed an array\n * it cannot render). Component names encode both axes — `AFormLink`/`ATableLink` are the inline\n * pair, `AForm`/`ATable` the expanding pair — but only the inline/expand half is authoritative.\n *\n * @public\n */\nexport type LinkExpansion = 'inline' | 'expand'\n\n/**\n * Canonical link component → expansion. Only components Stonecrop ships with appear here; an\n * unmapped (custom) component has none, and callers treat that as `expand` — the behaviour that\n * predates this map, so a custom component can never silently collapse a link to a picker.\n * @public\n */\nexport const COMPONENT_LINK_EXPANSION: Record<string, LinkExpansion> = {\n\tAFormLink: 'inline',\n\tAForm: 'expand',\n\tATable: 'expand',\n}\n\n/**\n * Resolve a component's link expansion, or `undefined` for an absent/unmapped component.\n * @public\n */\nexport function componentLinkExpansion(component?: string): LinkExpansion | undefined {\n\treturn component ? COMPONENT_LINK_EXPANSION[component] : undefined\n}\n\n/**\n * How a link field renders.\n *\n * - `inline` — a scalar id-picker; the target is *not* expanded (the field keeps its own value\n *   and carries a `doctype` prop for async display-text resolution and navigation).\n * - `record` — the target doctype is resolved and embedded as a nested form.\n * - `table` — the target doctype is resolved and embedded as a child table.\n *\n * @public\n */\nexport type LinkRenderMode = 'inline' | 'record' | 'table'\n\n/**\n * Decide how a *declared* link (one with a `LinkDeclaration`) renders.\n *\n * Two independent axes: the **component** picks inline vs expand, and when expanding the\n * **cardinality** picks record vs table (many → table). The declaration's component wins over the\n * field's, matching the precedence the resolver already uses for the rendered component.\n *\n * This is the single definition of \"does this link expand\" — it is consumed by both the client\n * resolver (which builds the nested schema) and the server column builder (which must still\n * SELECT an `inline` link's FK column). Call it; never re-derive the rule at the call site, or\n * the two will drift and the client will render a table for a column the server never selected.\n *\n * @param link - the link declaration (only `component` and `cardinality` are consulted)\n * @param fieldComponent - the linked field's own `component`, used when the declaration names none\n * @public\n */\nexport function resolveLinkRenderMode(\n\tlink: { component?: string; cardinality?: string },\n\tfieldComponent?: string\n): LinkRenderMode {\n\tif (componentLinkExpansion(link.component ?? fieldComponent) === 'inline') return 'inline'\n\treturn link.cardinality === 'noneOrMany' || link.cardinality === 'atLeastOne' ? 'table' : 'record'\n}\n\n/**\n * Every component Stonecrop ships with that can render a value field, sorted by name.\n *\n * The union of the two maps above is the definition, not a copy of it: a shipped component either\n * categorises a value ({@link COMPONENT_CATEGORY}) or is one of the link containers that has no\n * value of its own ({@link COMPONENT_LINK_EXPANSION}'s `AForm`/`ATable`). `AFieldset` is absent by\n * the same rule — it is a `kind: 'fieldset'` container, so it is never a value field's component.\n *\n * `component` is an **open** axis: any string is valid, and naming a custom component is how an app\n * renders a field Stonecrop ships no widget for. This list is therefore the set to *suggest* to an\n * author, and to check first-party data against — never a set to validate arbitrary input against.\n *\n * @public\n */\nexport const CANONICAL_COMPONENTS: readonly string[] = [\n\t...new Set([...Object.keys(COMPONENT_CATEGORY), ...Object.keys(COMPONENT_LINK_EXPANSION)]),\n].toSorted()\n","import { componentLinkExpansion } from './component-meta'\nimport type { DoctypeField } from './field'\nimport { flattenFields } from './flatten'\n\n/**\n * Reduce a record's *inline* link values to the ids that get persisted.\n *\n * The adapter returns an inline link as `{ id, displayText }`, so that is what a record holds\n * everywhere it is read — the store, a list row, a form field. A column takes the id alone, so\n * this is the single definition of the shape a record leaves in, and it belongs at the boundary\n * a record crosses on its way to the server, never on the way into the store.\n *\n * Doing it on the way in destroys the text the adapter looked up: nothing else holds it, so the\n * field that resolved a moment ago renders its raw id, and the same record then renders\n * differently depending on whether anything had edited the form yet. That is the bug this exists\n * to prevent, and its damage is a wrong render, not a throw.\n *\n * Only *inline* links may be reduced. An inline link's value is indistinguishable by inspection\n * from an expanded one (`{ id, ...the whole target record }`), so `component` — which states\n * which of the two a field is — is what tells them apart, via {@link componentLinkExpansion}.\n * Reducing an expanded link would send the id in place of the record.\n *\n * Fieldsets are descended into in both shapes a record appears in: flat, as the store and the\n * server hold it, and nested under the fieldset's own key, as a form emits it.\n *\n * @param fields - the doctype's top-level fields\n * @param record - the record to reduce; not mutated\n * @returns a shallow copy with every inline link reduced to its id\n * @public\n */\nexport function unwrapInlineLinks(fields: readonly DoctypeField[], record: Record<string, any>): Record<string, any> {\n\tconst inline = new Set(\n\t\tflattenFields(fields)\n\t\t\t.filter(field => field.kind === 'field' && Boolean(field.doctype))\n\t\t\t.filter(field => componentLinkExpansion(field.component) === 'inline')\n\t\t\t.map(field => field.fieldname)\n\t)\n\tif (inline.size === 0) return record\n\n\tconst fieldsets = new Set(fields.filter(field => field.kind === 'fieldset').map(field => field.fieldname))\n\treturn unwrapWith(inline, fieldsets, record)\n}\n\nfunction unwrapWith(\n\tinline: ReadonlySet<string>,\n\tfieldsets: ReadonlySet<string>,\n\trecord: Record<string, any>\n): Record<string, any> {\n\tconst result: Record<string, any> = { ...record }\n\tfor (const [key, value] of Object.entries(result)) {\n\t\tif (value === null || typeof value !== 'object' || Array.isArray(value)) continue\n\t\tif (inline.has(key)) {\n\t\t\t// `'id' in value` rather than a truthiness test: an inline link that was never resolved\n\t\t\t// is still a bare scalar, and reducing it a second time would be a no-op at best.\n\t\t\tif ('id' in value) result[key] = value.id\n\t\t} else if (fieldsets.has(key)) {\n\t\t\tresult[key] = unwrapWith(inline, fieldsets, value)\n\t\t}\n\t}\n\treturn result\n}\n"],"names":["COMPONENT_CATEGORY","componentCategory","component","COMPONENT_LINK_EXPANSION","componentLinkExpansion","resolveLinkRenderMode","link","fieldComponent","CANONICAL_COMPONENTS","unwrapInlineLinks","fields","record","inline","flattenFields","field","fieldsets","unwrapWith","result","key","value"],"mappings":";AAmBO,MAAMA,IAAwD;AAAA,EACpE,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,eAAe;AAAA,EACf,WAAW;AAAA,EACX,OAAO;AAAA,EACP,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,WAAW;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,mBAAmB;AAAA,EACnB,aAAa;AAAA,EACb,WAAW;AAAA,EACX,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,gBAAgB;AACjB;AAOO,SAASC,EAAkBC,GAAmD;AACpF,SAAOA,IAAYF,EAAmBE,CAAS,IAAI;AACpD;AAsBO,MAAMC,IAA0D;AAAA,EACtE,WAAW;AAAA,EACX,OAAO;AAAA,EACP,QAAQ;AACT;AAMO,SAASC,EAAuBF,GAA+C;AACrF,SAAOA,IAAYC,EAAyBD,CAAS,IAAI;AAC1D;AA8BO,SAASG,EACfC,GACAC,GACiB;AACjB,SAAIH,EAAuBE,EAAK,aAAaC,CAAc,MAAM,WAAiB,WAC3ED,EAAK,gBAAgB,gBAAgBA,EAAK,gBAAgB,eAAe,UAAU;AAC3F;AAgBO,MAAME,IAA0C;AAAA,EACtD,GAAG,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAKR,CAAkB,GAAG,GAAG,OAAO,KAAKG,CAAwB,CAAC,CAAC;AAC1F,EAAE,SAAA;ACxGK,SAASM,EAAkBC,GAAiCC,GAAkD;AACpH,QAAMC,IAAS,IAAI;AAAA,IAClBC,EAAcH,CAAM,EAClB,OAAO,CAAAI,MAASA,EAAM,SAAS,WAAW,EAAQA,EAAM,OAAQ,EAChE,OAAO,CAAAA,MAASV,EAAuBU,EAAM,SAAS,MAAM,QAAQ,EACpE,IAAI,CAAAA,MAASA,EAAM,SAAS;AAAA,EAAA;AAE/B,MAAIF,EAAO,SAAS,EAAG,QAAOD;AAE9B,QAAMI,IAAY,IAAI,IAAIL,EAAO,OAAO,CAAAI,MAASA,EAAM,SAAS,UAAU,EAAE,IAAI,CAAAA,MAASA,EAAM,SAAS,CAAC;AACzG,SAAOE,EAAWJ,GAAQG,GAAWJ,CAAM;AAC5C;AAEA,SAASK,EACRJ,GACAG,GACAJ,GACsB;AACtB,QAAMM,IAA8B,EAAE,GAAGN,EAAA;AACzC,aAAW,CAACO,GAAKC,CAAK,KAAK,OAAO,QAAQF,CAAM;AAC/C,IAAIE,MAAU,QAAQ,OAAOA,KAAU,YAAY,MAAM,QAAQA,CAAK,MAClEP,EAAO,IAAIM,CAAG,IAGb,QAAQC,MAAOF,EAAOC,CAAG,IAAIC,EAAM,MAC7BJ,EAAU,IAAIG,CAAG,MAC3BD,EAAOC,CAAG,IAAIF,EAAWJ,GAAQG,GAAWI,CAAK;AAGnD,SAAOF;AACR;"}

package/dist/record.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"record.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/schema.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"6.0.3"}

package/dist/src/badge.d.ts

@@ -1,74 +0,0 @@
-import type { FieldOptions } from './field';
-/**
- * Semantic badge variant. Maps to theme tokens `--sc-badge-{variant}-*`.
- * @public
- */
-export type BadgeVariant = 'neutral' | 'success' | 'warning' | 'danger' | 'brand';
-/**
- * Where ABadge paints the same descriptor.
- * @public
- */
-export type BadgePresentation = 'cell-fill' | 'input-accent';
-/**
- * Per-choice badge configuration in a Select options map.
- * @public
- */
-export interface BadgeSpecObject {
-    variant?: BadgeVariant;
-    color?: string;
-    label?: string;
-}
-/**
- * Value in a choice→badge map: shorthand variant or object form.
- * @public
- */
-export type BadgeSpec = BadgeVariant | BadgeSpecObject;
-/**
- * Select field options when choices carry badge colors.
- * @public
- */
-export interface SelectOptions extends Record<string, unknown> {
-    choices: string[];
-    badges?: Record<string, BadgeSpec>;
-}
-/**
- * Resolved badge for rendering. Returned by `format` or built from an options map.
- * @public
- */
-export interface BadgeDescriptor {
-    label: string;
-    variant?: BadgeVariant;
-    color?: string;
-}
-/**
- * True when `value` is a resolved badge descriptor for ACell / ADropdown.
- * @public
- */
-export declare function isBadgeDescriptor(value: unknown): value is BadgeDescriptor;
-/**
- * True when `options` is a Select choice map (`{ Open: "warning", ... }` or
- * `{ choices: [...], badges: {...} }`), not a quantity/currency/code config bag.
- * @public
- */
-export declare function isSelectChoiceMap(options: FieldOptions | undefined): options is Record<string, BadgeSpec>;
-/**
- * True when `options` uses the structured SelectOptions shape.
- * @public
- */
-export declare function isSelectOptions(options: FieldOptions | undefined): options is SelectOptions;
-/**
- * Dropdown / filter choice strings.
- * @public
- */
-export declare function selectChoices(options: FieldOptions | undefined): string[];
-/**
- * Resolve a stored choice value to a badge descriptor using field options.
- * @public
- */
-export declare function lookupBadge(options: FieldOptions | undefined, key: string | undefined): BadgeDescriptor | undefined;
-/**
- * Whether field options carry any badge mapping.
- * @public
- */
-export declare function hasBadgeOptions(options: FieldOptions | undefined): boolean;
-//# sourceMappingURL=badge.d.ts.map

package/dist/src/badge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"badge.d.ts","sourceRoot":"","sources":["../../src/badge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEjF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,cAAc,CAAA;AAE5D;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,eAAe,CAAA;AAEtD;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAsCD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAS1E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAUzG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,IAAI,aAAa,CAG3F;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,EAAE,CAOzE;AAgCD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAOnH;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,CAK1E"}

package/dist/src/badge.js

@@ -1,158 +0,0 @@
-const BADGE_VARIANTS = new Set(['neutral', 'success', 'warning', 'danger', 'brand']);
-const BADGE_SPEC_OBJECT_KEYS = new Set(['variant', 'color', 'label']);
-function isOptionsRecord(options) {
-    return !Array.isArray(options);
-}
-function isBadgeVariant(value) {
-    return typeof value === 'string' && BADGE_VARIANTS.has(value);
-}
-function isBadgeSpecObject(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    for (const key of Object.keys(value)) {
-        if (!BADGE_SPEC_OBJECT_KEYS.has(key))
-            return false;
-    }
-    const obj = value;
-    if (obj.variant !== undefined && !isBadgeVariant(obj.variant))
-        return false;
-    if (obj.color !== undefined && typeof obj.color !== 'string')
-        return false;
-    if (obj.label !== undefined && typeof obj.label !== 'string')
-        return false;
-    return true;
-}
-function isBadgeSpec(value) {
-    return isBadgeVariant(value) || isBadgeSpecObject(value);
-}
-/**
- * Narrows an options record to the structured `{ choices, badges }` form. A type predicate rather
- * than a cast: `SelectOptions` requires `choices`, so asserting into it trips `no-unsafe-type-assertion`.
- */
-function isStructuredSelectOptions(options) {
-    return Array.isArray(options.choices);
-}
-/**
- * True when `value` is a resolved badge descriptor for ACell / ADropdown.
- * @public
- */
-export function isBadgeDescriptor(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    // Partial<> keeps this a widening assertion; asserting into BadgeDescriptor itself (required
-    // `label`) narrows, which `no-unsafe-type-assertion` rejects.
-    const obj = value;
-    if (typeof obj.label !== 'string')
-        return false;
-    if (obj.variant !== undefined && !isBadgeVariant(obj.variant))
-        return false;
-    if (obj.color !== undefined && typeof obj.color !== 'string')
-        return false;
-    return true;
-}
-/**
- * True when `options` is a Select choice map (`{ Open: "warning", ... }` or
- * `{ choices: [...], badges: {...} }`), not a quantity/currency/code config bag.
- * @public
- */
-export function isSelectChoiceMap(options) {
-    if (options === undefined || Array.isArray(options) || !isOptionsRecord(options))
-        return false;
-    if (isStructuredSelectOptions(options)) {
-        const badges = options.badges;
-        if (badges === undefined)
-            return false;
-        return Object.values(badges).every(isBadgeSpec);
-    }
-    const entries = Object.entries(options);
-    if (entries.length === 0)
-        return false;
-    return entries.every(([, value]) => isBadgeSpec(value));
-}
-/**
- * True when `options` uses the structured SelectOptions shape.
- * @public
- */
-export function isSelectOptions(options) {
-    if (options === undefined || Array.isArray(options) || !isOptionsRecord(options))
-        return false;
-    return isStructuredSelectOptions(options);
-}
-/**
- * Dropdown / filter choice strings.
- * @public
- */
-export function selectChoices(options) {
-    if (options === undefined)
-        return [];
-    if (Array.isArray(options))
-        return options;
-    if (!isOptionsRecord(options))
-        return [];
-    if (isStructuredSelectOptions(options))
-        return options.choices;
-    if (isSelectChoiceMap(options))
-        return Object.keys(options);
-    return [];
-}
-function normalizeBadgeSpec(spec, key) {
-    if (isBadgeVariant(spec)) {
-        return { label: key, variant: spec };
-    }
-    // A malformed spec still names a real choice, so keep the label and drop only the styling.
-    // Reading `.variant`/`.color` off an unvalidated value is what let a misspelt variant reach the
-    // DOM as an unmatched class, and threw outright on null.
-    if (!isBadgeSpecObject(spec)) {
-        return { label: key };
-    }
-    return {
-        label: spec.label ?? key,
-        variant: spec.variant,
-        color: spec.color,
-    };
-}
-function lookupFromBareMap(map, key) {
-    if (key === undefined || key === '')
-        return undefined;
-    if (!(key in map))
-        return undefined;
-    return normalizeBadgeSpec(map[key], key);
-}
-function lookupFromStructured(options, key) {
-    if (key === undefined || key === '')
-        return undefined;
-    const badges = options.badges;
-    if (!badges || !(key in badges))
-        return undefined;
-    return normalizeBadgeSpec(badges[key], key);
-}
-/**
- * Resolve a stored choice value to a badge descriptor using field options.
- * @public
- */
-export function lookupBadge(options, key) {
-    if (options === undefined || key === undefined || key === '')
-        return undefined;
-    if (Array.isArray(options))
-        return undefined;
-    if (!isOptionsRecord(options))
-        return undefined;
-    if (isStructuredSelectOptions(options))
-        return lookupFromStructured(options, key);
-    if (isSelectChoiceMap(options))
-        return lookupFromBareMap(options, key);
-    return undefined;
-}
-/**
- * Whether field options carry any badge mapping.
- * @public
- */
-export function hasBadgeOptions(options) {
-    if (options === undefined || Array.isArray(options))
-        return false;
-    if (!isOptionsRecord(options))
-        return false;
-    if (isStructuredSelectOptions(options))
-        return options.badges !== undefined && Object.keys(options.badges).length > 0;
-    return isSelectChoiceMap(options);
-}

package/dist/src/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

package/dist/src/cli.js

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-/* oxlint-disable no-console */
-/**
- * Stonecrop Schema CLI
- *
- * Converts GraphQL introspection results to Stonecrop doctype JSON schemas.
- *
- * Usage:
- *   stonecrop-schema generate --endpoint <url> --output <dir>
- *   stonecrop-schema generate --introspection <file.json> --output <dir>
- *   stonecrop-schema generate --sdl <file.graphql> --output <dir>
- *
- * @packageDocumentation
- */
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { resolve, join } from 'node:path';
-import { parseArgs } from 'node:util';
-import { getIntrospectionQuery } from 'graphql';
-import { authoredPrimaryKey } from './converter/authored';
-import { convertGraphQLSchema, formatDoctypeDrift, mergeIntrospectedDoctype, planGeneration } from './converter/index';
-import { stripFieldKind } from './field';
-import { validateDoctype } from './validation';
-/**
- * Fetch an introspection result from a live GraphQL endpoint.
- *
- * @param endpoint - The GraphQL endpoint URL
- * @param headers - Optional HTTP headers
- * @returns The introspection query result
- */
-async function fetchIntrospection(endpoint, headers) {
-    const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            ...headers,
-        },
-        body: JSON.stringify({
-            query: getIntrospectionQuery(),
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch introspection: ${response.status} ${response.statusText}`);
-    }
-    const json = await response.json();
-    if (json.errors?.length) {
-        throw new Error(`GraphQL errors: ${json.errors.map(e => e.message).join(', ')}`);
-    }
-    if (!json.data) {
-        throw new Error('No data in introspection response');
-    }
-    return json.data;
-}
-async function main() {
-    const { values, positionals } = parseArgs({
-        allowPositionals: true,
-        options: {
-            endpoint: { type: 'string', short: 'e' },
-            introspection: { type: 'string', short: 'i' },
-            sdl: { type: 'string', short: 's' },
-            output: { type: 'string', short: 'o' },
-            include: { type: 'string' },
-            exclude: { type: 'string' },
-            names: { type: 'string' },
-            'custom-scalars': { type: 'string' },
-            'include-unmapped': { type: 'boolean', default: false },
-            'no-aggregates': { type: 'boolean', default: false },
-            check: { type: 'boolean', default: false },
-            help: { type: 'boolean', short: 'h' },
-        },
-    });
-    const command = positionals[0];
-    if (values.help || !command) {
-        printHelp();
-        process.exit(command ? 0 : 1);
-    }
-    if (command !== 'generate') {
-        console.error(`Unknown command: ${command}`);
-        console.error('Available commands: generate');
-        process.exit(1);
-    }
-    // Determine source
-    const sourceCount = [values.endpoint, values.introspection, values.sdl].filter(Boolean).length;
-    if (sourceCount !== 1) {
-        console.error('Exactly one of --endpoint, --introspection, or --sdl must be provided');
-        process.exit(1);
-    }
-    if (!values.output) {
-        console.error('--output <dir> is required');
-        process.exit(1);
-    }
-    const outputDir = resolve(values.output);
-    // Build conversion options
-    const options = {
-        includeUnmappedMeta: values['include-unmapped'],
-    };
-    if (values.include) {
-        options.include = values.include.split(',').map(s => s.trim());
-    }
-    if (values.exclude) {
-        options.exclude = values.exclude.split(',').map(s => s.trim());
-    }
-    if (values.names) {
-        const namesPath = resolve(values.names);
-        options.doctypeNames = JSON.parse(readFileSync(namesPath, 'utf-8'));
-    }
-    options.onWarning = message => console.warn(`  WARN: ${message}`);
-    if (values['custom-scalars']) {
-        const scalarsPath = resolve(values['custom-scalars']);
-        const scalarsContent = readFileSync(scalarsPath, 'utf-8');
-        options.customScalars = JSON.parse(scalarsContent);
-    }
-    // Resolve source
-    let source;
-    if (values.endpoint) {
-        console.log(`Fetching introspection from ${values.endpoint}...`);
-        source = await fetchIntrospection(values.endpoint);
-    }
-    else if (values.introspection) {
-        const filePath = resolve(values.introspection);
-        const content = readFileSync(filePath, 'utf-8');
-        const parsed = JSON.parse(content);
-        // Handle both { data: { __schema: ... } } and { __schema: ... } formats
-        source = parsed.data ?? parsed;
-    }
-    else {
-        const filePath = resolve(values.sdl);
-        source = readFileSync(filePath, 'utf-8');
-    }
-    // Convert
-    const entities = convertGraphQLSchema(source, options);
-    if (entities.length === 0) {
-        console.warn('No entity types found in the schema. Check your include/exclude filters.');
-        process.exit(0);
-    }
-    // Read the identity each authored doctype declares, before planning rather than during the write
-    // loop below. SDL cannot express which UNIQUE column is a table's key, so for a natural-key
-    // doctype the declaration in the file is the only answer that exists — and planning is what
-    // decides whether the aggregate can be built at all. Reading it 20 lines later, as the loop
-    // does, made the "declare a primaryKey and re-run" warning a dead end: re-running after
-    // declaring one changed nothing.
-    const identity = {};
-    for (const entity of entities) {
-        const entityPath = join(outputDir, `${entity.slug}.json`);
-        if (!existsSync(entityPath))
-            continue;
-        const declared = authoredPrimaryKey(JSON.parse(readFileSync(entityPath, 'utf-8')));
-        if (declared !== undefined)
-            identity[entity.name] = declared;
-    }
-    // Each table yields two doctypes — the entity and its aggregate — written as peers, one file
-    // each, along with what each is verified against. See `planGeneration`.
-    const doctypes = planGeneration(entities, {
-        noAggregates: values['no-aggregates'],
-        identity,
-        onWarning: message => console.warn(`  WARN: ${message}`),
-    });
-    // Write output
-    if (!existsSync(outputDir)) {
-        mkdirSync(outputDir, { recursive: true });
-    }
-    let warnings = 0;
-    let errors = 0;
-    let changed = 0;
-    const driftLines = [];
-    for (const { generated, basis, subset } of doctypes) {
-        const fileName = `${generated.slug}.json`;
-        const filePath = join(outputDir, fileName);
-        // When a doctype already exists it is the source of truth: generation confirms it and adds
-        // provenance markers, and reports anything it disagrees with rather than applying it. A
-        // doctype legitimately declares identity the schema cannot express — most often a natural
-        // key that is a UNIQUE constraint, not the table's PRIMARY KEY — and overwriting that would
-        // silently re-key the doctype on every run. A first generation has nothing to merge into,
-        // so converter output is written verbatim.
-        let output = generated;
-        if (existsSync(filePath)) {
-            const { doctype: merged, drift } = mergeIntrospectedDoctype(JSON.parse(readFileSync(filePath, 'utf-8')), basis, {
-                subset,
-            });
-            output = merged;
-            driftLines.push(...formatDoctypeDrift(drift));
-        }
-        // Serialize the merged object directly. Never round-trip it through the Zod parser first:
-        // that runs in strip mode and would silently drop every key this package does not model,
-        // `handler` on an action being the one consumers actually rely on.
-        //
-        // `kind` is dropped on the way out because it is the discriminated-union tag the parser
-        // synthesizes, not authored data — `injectKind` puts it back on every read. Writing it made
-        // the generator and the docbuilder disagree with hand-authored files about what a doctype
-        // looks like, and re-added the key on every regeneration.
-        const serializable = { ...output };
-        if (Array.isArray(serializable.fields)) {
-            serializable.fields = serializable.fields.map(stripFieldKind);
-        }
-        const json = JSON.stringify(serializable, null, '\t') + '\n';
-        const unchanged = existsSync(filePath) && readFileSync(filePath, 'utf-8') === json;
-        if (!unchanged)
-            changed++;
-        if (!values.check && !unchanged) {
-            writeFileSync(filePath, json, 'utf-8');
-        }
-        // Validate the output
-        const validation = validateDoctype(output);
-        if (!validation.success) {
-            errors++;
-            console.error(`  ERROR: ${fileName} failed validation:`);
-            for (const err of validation.errors) {
-                console.error(`    ${err.path.join('.')}: ${err.message}`);
-            }
-        }
-        else {
-            // Check for unmapped fields
-            const unmappedFields = generated.fields.filter((f) => f._unmapped);
-            if (unmappedFields.length > 0) {
-                warnings++;
-                console.warn(`  WARN: ${fileName} has ${unmappedFields.length} unmapped field(s): ${unmappedFields
-                    .map((f) => f.fieldname)
-                    .join(', ')}`);
-            }
-        }
-    }
-    if (driftLines.length > 0) {
-        console.log('\nDrift between the authored doctypes and the schema (reported, not applied):');
-        for (const line of driftLines)
-            console.log(line);
-    }
-    console.log(`\n${values.check ? 'Checked' : 'Generated'} ${doctypes.length} doctype(s) in ${outputDir}` +
-        (changed ? ` (${changed} ${values.check ? 'would change' : 'written'})` : ' (all up to date)') +
-        (warnings ? ` (${warnings} with warnings)` : '') +
-        (errors ? ` (${errors} with errors)` : ''));
-    if (errors > 0 || (values.check && changed > 0)) {
-        process.exit(1);
-    }
-}
-function printHelp() {
-    console.log(`
-stonecrop-schema - Convert GraphQL schemas to Stonecrop doctypes
-
-USAGE:
-  stonecrop-schema generate [options]
-
-SOURCE (exactly one required):
-  --endpoint, -e <url>         Fetch introspection from a live GraphQL endpoint
-  --introspection, -i <file>   Read from a saved introspection JSON file
-  --sdl, -s <file>             Read from a GraphQL SDL (.graphql) file
-
-OUTPUT:
-  --output, -o <dir>           Directory to write doctype JSON files (required)
-
-OPTIONS:
-  --include <types>            Comma-separated list of type names to include
-  --exclude <types>            Comma-separated list of type names to exclude
-  --names <file>               JSON file mapping GraphQL type name to doctype name
-  --custom-scalars <file>      JSON file mapping custom scalar names to field templates
-  --include-unmapped           Include _graphqlType metadata on unmapped fields
-  --no-aggregates              Emit only the entity doctype, not its aggregate
-  --check                      Report drift and exit non-zero if anything would change; write nothing
-  --help, -h                   Show this help message
-
-Each table generates TWO doctypes: the entity (every column, backs the record form) and its
-aggregate (the collection view, identity column only by default), named as simple plurals —
-'task.json' and 'tasks.json'. Widen an aggregate by adding fields to it — curation survives
-regeneration. A doctype whose name is already plural gets no aggregate, because it would claim
-its own name and its own file; the run says so and still writes the entity.
-
-An aggregate needs an identity column. A table keyed on 'id' gives one up; for a natural key,
-declare 'primaryKey' on the field in the entity's own file and re-run — the aggregate is keyed
-on whatever that file declares.
-
-NOTE: an existing doctype file is the source of truth. Regeneration verifies it against the
-schema and adds 'source: introspected' markers; it reports disagreements rather than
-overwriting them, so hand-curation survives. Use --check in CI.
-
-EXAMPLES:
-  # From a live PostGraphile server
-  stonecrop-schema generate -e http://localhost:5000/graphql -o ./schemas
-
-  # From a saved introspection result
-  stonecrop-schema generate -i introspection.json -o ./schemas
-
-  # From an SDL file with custom scalars
-  stonecrop-schema generate -s schema.graphql -o ./schemas \\
-    --custom-scalars custom-scalars.json
-
-  # Only convert specific types
-  stonecrop-schema generate -e http://localhost:5000/graphql -o ./schemas \\
-    --include "User,Post,Comment"
-`);
-}
-main().catch(err => {
-    console.error('Error:', err.message);
-    process.exit(1);
-});