@bendyline/squisq 1.4.0 → 1.5.0

package/dist/inlineIconMarker-CiE8Hlvz.d.ts

@@ -0,0 +1,59 @@
+/**
+ * iconData.ts — GENERATED FILE
+ *
+ * FontAwesome Free icon catalog. Run `node scripts/generate-icon-data.mjs`
+ * to regenerate after bumping @fortawesome/fontawesome-free.
+ *
+ * Entry count: 2141
+ * Generated:   2026-05-14T03:38:13.863Z
+ */
+type IconFamily = 'brands' | 'solid' | 'regular';
+interface IconEntry {
+    /** Icon name without the `fa-` prefix (e.g. `github`). */
+    name: string;
+    /** Family bucket — drives the `fa-brands` / `fa-solid` / `fa-regular` class. */
+    family: IconFamily;
+    /** Human display label (used by the picker tooltip). */
+    label: string;
+    /** Lowercase, space-joined search keywords. */
+    keywords: string;
+    /** FontAwesome Private-Use-Area codepoint as a hex string (e.g. `'f09b'`).
+     *  Use `String.fromCodePoint(parseInt(unicode, 16))` to get the rendered
+     *  glyph when the FA font is loaded. */
+    unicode: string;
+}
+declare const ICONS: IconEntry[];
+
+/**
+ * Inline-icon markers for template text.
+ *
+ * Slide templates flatten rich markdown body content into strings before
+ * rendering. Inline icons need to survive that flattening step, so we encode
+ * them as sentinel-delimited text markers and let `TextLayer` turn them back
+ * into FontAwesome glyphs when rendering.
+ */
+
+/** Encode a resolved icon (family + name) as an embeddable text marker. */
+declare function iconMarker(family: IconFamily, name: string): string;
+/** True when a string contains at least one encoded icon marker. */
+declare function hasIconMarker(value: string): boolean;
+/** Remove every icon marker, leaving a clean plain-text projection. */
+declare function stripIconMarkers(value: string): string;
+/** A run of a marker-bearing string: literal text or a resolved icon. */
+type IconTextRun = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'icon';
+    family: IconFamily;
+    name: string;
+};
+/**
+ * Split a string into ordered text/icon runs. Text between markers is
+ * preserved verbatim, including whitespace; each marker becomes an icon run.
+ */
+declare function splitIconMarkers(value: string): IconTextRun[];
+/** FontAwesome CSS class for a resolved icon, e.g. `fa-solid fa-rocket`. */
+declare function iconClass(family: IconFamily, name: string): string;
+
+export { ICONS as I, type IconEntry as a, type IconFamily as b, type IconTextRun as c, iconMarker as d, stripIconMarkers as e, hasIconMarker as h, iconClass as i, splitIconMarkers as s };

package/dist/jsonForm/index.d.ts

@@ -1,14 +1,191 @@
 /**
- * `@bendyline/squisq/jsonForm` — headless JSON Form logic.
+ * JSON Form types — Squisq's hint vocabulary layered on JSON Schema.
  *
- * Pure utilities consumed by `<JsonView>` (read-only) in
- * `@bendyline/squisq-react` and `<JsonEditor>` (editable) in
- * `@bendyline/squisq-editor-react`. Zero React deps.
- */
-export type { ControlKind, SquisqHints, SquisqWhen, SquisqAnnotatedSchema, JsonFormValidationError, JsonFormValidator, } from './types.js';
-export { chooseControl, primaryType, arrayItemKind } from './chooseControl.js';
-export { evaluateWhen, resolveFlag } from './evaluateWhen.js';
-export { toPointer, pointerSegments, getByPointer, setByPointer, resolveRef } from './pointer.js';
-export { inferSchema } from './inferSchema.js';
-export type { InferSchemaOptions } from './inferSchema.js';
-//# sourceMappingURL=index.d.ts.map
+ * Hints live inline on a JSON Schema under a single `squisq` key. The
+ * schema remains a valid JSON Schema; the extra key is ignored by
+ * standard validators. Renderers consult the hints to pick a control
+ * and tune its presentation.
+ */
+/**
+ * Every concrete control rendered by `<JsonView>` and `<JsonEditor>`.
+ *
+ * Auto-defaults pick one based on schema shape; hosts override via
+ * `squisq.control` when they want something specific (e.g. radio over
+ * segmented for a long, descriptive enum).
+ */
+type ControlKind = 'text' | 'multiline' | 'richtext' | 'color' | 'date' | 'time' | 'datetime' | 'slider' | 'stepper' | 'segmented' | 'radio' | 'combobox' | 'toggle' | 'checkbox' | 'card' | 'card-stack' | 'chip-bin' | 'tabs' | 'group';
+/**
+ * Conditional rule: looked up by field path against the root data and
+ * compared with one of the operators. The first defined operator wins
+ * (in declaration order: equals, oneOf, matches, truthy).
+ */
+interface SquisqWhen {
+    /**
+     * Path to the controlling field, relative to the root data.
+     * Accepts dotted-path (`user.role`) or JSON Pointer (`/user/role`).
+     */
+    field: string;
+    equals?: unknown;
+    oneOf?: readonly unknown[];
+    /** ECMAScript regex source; matched against the string value. */
+    matches?: string;
+    /** When true, condition holds if value is truthy; when false, if falsy. */
+    truthy?: boolean;
+}
+/**
+ * Hints for a single schema node. Attach via `squisq` on any JSON
+ * Schema object — properties, items, the root, or sub-schemas inside
+ * `oneOf`/`anyOf`.
+ */
+interface SquisqHints {
+    /** Force a specific control. If omitted, picked from type/format/enum cardinality. */
+    control?: ControlKind;
+    /** Override schema `title` for display. */
+    label?: string;
+    /** Override schema `description` for the inline helper text. */
+    help?: string;
+    /** Placeholder text for empty fields. */
+    placeholder?: string;
+    /** Suggested layout sizing in a parent grid. Renderers may ignore on narrow viewports. */
+    width?: 'full' | 'half' | 'third' | 'auto';
+    /** Hide the field — literal, or a `SquisqWhen` evaluated against root data. */
+    hidden?: boolean | SquisqWhen;
+    /** Disable the field — literal, or a `SquisqWhen` evaluated against root data. */
+    disabled?: boolean | SquisqWhen;
+    /** Override schema's required-ness for the UI only. */
+    required?: boolean;
+    /** For arrays of objects: how to label each card in a `card-stack`. */
+    itemLabel?: string | {
+        fromField: string;
+    };
+    /** Label for the "+ Add" button on arrays. */
+    addLabel?: string;
+    /** Label for the remove button on arrays. */
+    removeLabel?: string;
+    /** Slider/stepper visual step. Falls back to schema `multipleOf`. */
+    step?: number;
+    /** Optional human-readable labels for enum values. */
+    enumLabels?: Record<string, string>;
+}
+/**
+ * The subset of JSON Schema we understand, with an optional `squisq`
+ * key. We deliberately keep this as a structural type so any JSON
+ * Schema authored elsewhere can be passed in without conversion.
+ */
+interface SquisqAnnotatedSchema {
+    type?: string | readonly string[];
+    format?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    examples?: readonly unknown[];
+    enum?: readonly unknown[];
+    const?: unknown;
+    properties?: Record<string, SquisqAnnotatedSchema>;
+    required?: readonly string[];
+    additionalProperties?: boolean | SquisqAnnotatedSchema;
+    items?: SquisqAnnotatedSchema | readonly SquisqAnnotatedSchema[];
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    oneOf?: readonly SquisqAnnotatedSchema[];
+    anyOf?: readonly SquisqAnnotatedSchema[];
+    allOf?: readonly SquisqAnnotatedSchema[];
+    $ref?: string;
+    $defs?: Record<string, SquisqAnnotatedSchema>;
+    definitions?: Record<string, SquisqAnnotatedSchema>;
+    squisq?: SquisqHints;
+}
+/**
+ * A validation error reported by the consumer-supplied `validate` prop.
+ * Matches the shape of common validators (ajv, etc.) without depending
+ * on any specific one.
+ */
+interface JsonFormValidationError {
+    /** JSON Pointer to the failing value, e.g. `/sections/0/heading`. */
+    path: string;
+    /** Human-readable message. */
+    message: string;
+    /** Optional schema keyword that failed (e.g. "required", "minimum"). */
+    keyword?: string;
+}
+type JsonFormValidator = (value: unknown, schema: SquisqAnnotatedSchema) => readonly JsonFormValidationError[];
+
+/**
+ * Pick a `ControlKind` for a schema node. The single dispatcher used by
+ * both `<JsonView>` and `<JsonEditor>` so view and edit modes always
+ * agree on what each field _is_, even when their UIs differ.
+ *
+ * Order of precedence:
+ *   1. Explicit `squisq.control` hint
+ *   2. `format` keyword (color/date/time/datetime/markdown/textarea)
+ *   3. Enum cardinality (segmented vs. combobox)
+ *   4. Numeric range (slider when both min and max present)
+ *   5. String length (multiline when maxLength > 200)
+ *   6. Type-default (object/array/boolean/string/number)
+ */
+
+declare function chooseControl(schema: SquisqAnnotatedSchema): ControlKind;
+/** Return the first concrete type of a schema, ignoring `null` for nullable shorthand. */
+declare function primaryType(schema: SquisqAnnotatedSchema): string | undefined;
+/** Inspect `items` to decide whether an array holds objects or primitives. */
+declare function arrayItemKind(schema: SquisqAnnotatedSchema): 'object' | 'primitive';
+
+/**
+ * Evaluate a `SquisqWhen` rule against the current root data. Pure;
+ * renderers call this on every render with fresh data.
+ */
+
+declare function evaluateWhen(when: SquisqWhen, rootData: unknown): boolean;
+/**
+ * Resolve a `boolean | SquisqWhen` flag (used by `hidden`/`disabled`)
+ * to a final boolean. Literal booleans pass through.
+ */
+declare function resolveFlag(flag: boolean | SquisqWhen | undefined, rootData: unknown): boolean;
+
+/**
+ * JSON Pointer helpers (RFC 6901) plus immutable get/set, plus a tiny
+ * dotted-path normalizer so hosts can write `user.role` instead of
+ * `/user/role`. `$ref` resolution is local-only (`#/$defs/Foo`).
+ */
+
+/** Normalize a path to a JSON Pointer string. Accepts both forms. */
+declare function toPointer(path: string): string;
+/** Split a JSON Pointer into decoded segments. Empty string → []. */
+declare function pointerSegments(pointer: string): string[];
+/** Read a value from data by path (dotted or pointer). Returns undefined if missing. */
+declare function getByPointer(data: unknown, path: string): unknown;
+/**
+ * Return a structurally-shared copy of `data` with the value at `path`
+ * replaced. Intermediate objects/arrays are cloned along the path; the
+ * rest is shared by reference. Creates intermediate objects if missing.
+ */
+declare function setByPointer<T>(data: T, path: string, value: unknown): T;
+/**
+ * Resolve a local `$ref` (e.g. `#/$defs/Foo`) against the root schema.
+ * Returns the original schema if no `$ref` is present, or `undefined`
+ * if the reference cannot be resolved. Cross-document refs are not
+ * supported.
+ */
+declare function resolveRef(schema: SquisqAnnotatedSchema, root: SquisqAnnotatedSchema): SquisqAnnotatedSchema | undefined;
+
+/**
+ * Infer a JSON Schema from an example JSON value. Thin facade over
+ * `genson-js` so consumers don't depend on it directly and we can swap
+ * the implementation later.
+ */
+
+interface InferSchemaOptions {
+    /** Additional samples merged into the inferred schema for broader coverage. */
+    additionalSamples?: readonly unknown[];
+}
+declare function inferSchema(sample: unknown, options?: InferSchemaOptions): SquisqAnnotatedSchema;
+
+export { type ControlKind, type InferSchemaOptions, type JsonFormValidationError, type JsonFormValidator, type SquisqAnnotatedSchema, type SquisqHints, type SquisqWhen, arrayItemKind, chooseControl, evaluateWhen, getByPointer, inferSchema, pointerSegments, primaryType, resolveFlag, resolveRef, setByPointer, toPointer };

package/dist/jsonForm/index.js

@@ -1,12 +1,27 @@
-/**
- * `@bendyline/squisq/jsonForm` — headless JSON Form logic.
- *
- * Pure utilities consumed by `<JsonView>` (read-only) in
- * `@bendyline/squisq-react` and `<JsonEditor>` (editable) in
- * `@bendyline/squisq-editor-react`. Zero React deps.
- */
-export { chooseControl, primaryType, arrayItemKind } from './chooseControl.js';
-export { evaluateWhen, resolveFlag } from './evaluateWhen.js';
-export { toPointer, pointerSegments, getByPointer, setByPointer, resolveRef } from './pointer.js';
-export { inferSchema } from './inferSchema.js';
+import {
+  arrayItemKind,
+  chooseControl,
+  evaluateWhen,
+  getByPointer,
+  inferSchema,
+  pointerSegments,
+  primaryType,
+  resolveFlag,
+  resolveRef,
+  setByPointer,
+  toPointer
+} from "../chunk-K32VJONL.js";
+export {
+  arrayItemKind,
+  chooseControl,
+  evaluateWhen,
+  getByPointer,
+  inferSchema,
+  pointerSegments,
+  primaryType,
+  resolveFlag,
+  resolveRef,
+  setByPointer,
+  toPointer
+};
 //# sourceMappingURL=index.js.map

package/dist/jsonForm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/jsonForm/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}