@nolwenture/formik-jsonschema-form 2.0.2 → 3.0.0-beta.1

package/dist/esm/v3/react/view/templates.js

@@ -0,0 +1,47 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { arrayTemplateMarkup, fieldTemplateMarkup, objectTemplateMarkup } from "../../raw/model/view/markup";
+import { elementProps } from "../../raw/model/view/fields";
+import { descriptionOf, titleOf } from "../../raw/model/view/values";
+import { hole } from "../../raw/model/vnode";
+import { useViewRender } from "./host";
+/** 2.x getInstrumentationAttributes. */
+const instrumentation = (props) => ({
+    "data-fjsf-path": props.name ?? "",
+    "data-fjsf-kind": props["data-fjsf-kind"],
+    "data-fjsf-required": props.required ? "true" : undefined,
+    "data-fjsf-readonly": props.schema?.readOnly ? "true" : undefined,
+    "data-fjsf-hidden": props["data-fjsf-hidden"],
+});
+/** 2.x getTitle/getDescription: an explicit `title`/`description` prop wins. */
+const chrome = (props, attrs) => {
+    const ui = props.uiSchema ?? {};
+    const name = props.name ?? "";
+    const { wrapperAttrs, titleAttrs, descriptionAttrs } = elementProps(ui, name);
+    return {
+        path: name,
+        attrs: { ...wrapperAttrs, ...attrs },
+        titleAttrs,
+        descriptionAttrs,
+        title: titleOf(props.title ? { ...ui, "ui:title": props.title } : ui, props.schema, name),
+        description: descriptionOf(props.description ? { ...ui, "ui:options": { ...ui["ui:options"], description: props.description } } : ui, props.schema),
+    };
+};
+const FieldTemplate = (props) => {
+    const render = useViewRender();
+    return _jsx(_Fragment, { children: render(fieldTemplateMarkup(chrome(props, instrumentation(props)), [hole()]), props.children) });
+};
+const ObjectFieldTemplate = (props) => {
+    const render = useViewRender();
+    const data = Object.fromEntries(Object.entries(props).filter(([key]) => key.startsWith("data-")));
+    return _jsx(_Fragment, { children: render(objectTemplateMarkup(chrome(props, { ...data, ...instrumentation(props) }), [hole()]), props.children) });
+};
+const ArrayFieldTemplate = (props) => {
+    const render = useViewRender();
+    const items = Array.isArray(props.items) ? props.items.map((item, index) => props.renderItem(item, index)) : null;
+    return _jsx(_Fragment, { children: render(arrayTemplateMarkup(chrome(props, instrumentation(props)), [hole()]), items) });
+};
+export const FormViewTemplates = {
+    ArrayFieldTemplate,
+    FieldTemplate,
+    ObjectFieldTemplate,
+};

package/dist/types/common/types/Form.d.ts

@@ -1,32 +1,9 @@
-import { TemplatesType } from "../../Form/templates";
-import { FieldsType, ComponentsType } from "../../Form/types";
-import { Schema, UiSchema } from "./Schemas";
-export type FormProps<T> = React.PropsWithChildren<{
-    /** If true, disabled prop is passed down to each field on the form */
-    disabled?: boolean | undefined;
-    /** If true, array field schemas missing 'additionalItems' will replace it with 'items'  */
-    useItemsAsAdditionalItems?: boolean | undefined;
-    /** If true, properties in object fields' data that aren't in the schema will only be displayed if `additionalProperties` is enabled in the schema */
-    hideUnmarkedAdditionalProperties?: boolean;
-    /** If passed, enables the ordering of the additional properties in ObjectField. Actual ordering logic needs to be handled by this function as it involvces manipulating uiSchema, which is out side of the ObjectFields control*/
-    onAdditionalPropertyOrderChange?: (fieldName: string, oldOrder: string[], newOrder: string[]) => void;
-    className?: string | undefined;
-    /** Form schema */
-    schema: Schema;
-    /** Form uiSchema */
-    uiSchema?: UiSchema | undefined;
-    /** Data that is passed down to all fields. Used for implementing context aware fields */
-    formContext?: Record<string, any>;
-    formOptions?: Record<string, any>;
-    formLocalization?: Record<string, any>;
-    /** Dictionary of registered fields */
-    fields?: Partial<FieldsType>;
-    templates?: Partial<TemplatesType>;
-    components?: Partial<ComponentsType>;
-    /**
-     * If set to true, turns off HTML5 validation
-     * @default false
-     */
-    noHtml5Validate?: boolean | undefined;
-    hideSubmit?: boolean | undefined;
-}>;
+import type { Field } from "./Field";
+import type { TemplateType } from "./Templates";
+export type { FormProps } from "../../v3/react/form/root";
+/** `fields`: field components by name (built-ins and custom ones, 2.x Field contract). */
+export type FieldsType = Record<string, Field>;
+/** `templates`: template components by name (FieldTemplate, ObjectFieldTemplate, ArrayFieldTemplate, `ui:template` names). */
+export type TemplatesType = Record<string, TemplateType>;
+/** `registry.components`: the deprecated compat map (CM-a). Replacements go through `slots`. */
+export type ComponentsType = Record<string, any>;

package/dist/types/common/types/Utils.d.ts

@@ -0,0 +1,11 @@
+import type { UiSchema } from "./Schemas";
+/** extractUiSchema's argument. */
+export type ExtractUiSchemaProps = UiSchema | undefined;
+/**
+ * @deprecated 3.0.0: the global Yup `mixedOf` method is gone (validation no longer patches Yup); kept so
+ * existing type imports compile.
+ */
+export type MixedOfProps = {
+    itemSchemas: unknown[];
+    additionalItemSchema?: unknown;
+};

package/dist/types/common/types/index.d.ts

@@ -2,3 +2,5 @@ export * from "./Field";
 export * from "./Form";
 export * from "./Schemas";
 export * from "./Templates";
+export * from "./Utils";
+export type { FieldInfoBoxElementProps, FieldInfoProps } from "./FieldInfo";

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
-export * from "./common";
-export * from "./Form";
-export * from "./FormView";
-export * from "./utils";
+export * from "./v3/react";
+export * from "./v3/raw/compat/v2utils";
+export { SANITIZER_UNAVAILABLE, SanitizerUnavailableError, sanitizeHtml, setSanitizerWindow } from "./v3/raw/sanitize";
+export type { SanitizeHtmlOptions } from "./v3/raw/sanitize";
+export * from "./common/types";
+export { COMPONENT_TYPES, FormWrapper } from "./v3/react/compat";

package/dist/types/v3/codemod/bindings.d.ts

@@ -0,0 +1,18 @@
+export type Kind = "library" | "forwarder";
+export type Kinds = Map<string, Kind>;
+/** The component declared before `index` (`const X =` / `function X`): the owner of a JSX site. */
+export declare const enclosing: (source: string, index: number) => string | undefined;
+/** The end of a JSX opening tag that starts at `from` (braces and strings balanced), or -1. */
+export declare const tagEnd: (source: string, from: number) => number;
+export type Site = {
+    element: string;
+    index: number;
+    attr: number;
+    value: string;
+};
+/** Every `components=` in a JSX opening tag: the element, where it is, and the attribute's text. */
+export declare const componentsSites: (source: string) => Site[];
+/** The kinds of the names declared in one file, given the kinds of the names it imports (`known`). */
+export declare const localKinds: (source: string, known?: Kinds) => Kinds;
+/** The kinds of every file's names, following relative imports and re-exports between the given files. */
+export declare const resolveKinds: (sources: ReadonlyMap<string, string>, wrappers?: readonly string[]) => Map<string, Kinds>;

package/dist/types/v3/codemod/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/v3/codemod/migrate.d.ts

@@ -0,0 +1,8 @@
+import type { Report } from "./transform";
+export type Migration = {
+    outputs: Map<string, string>;
+    reports: Map<string, Report>;
+    forwarders: string[];
+    unhandled: number;
+};
+export declare const migrate: (sources: ReadonlyMap<string, string>, wrappers?: readonly string[]) => Migration;

package/dist/types/v3/codemod/package.d.ts

@@ -0,0 +1,2 @@
+/** The package the codemod rewrites imports and selectors of. */
+export declare const PACKAGE = "@nolwenture/formik-jsonschema-form";

package/dist/types/v3/codemod/slots.d.ts

@@ -0,0 +1,13 @@
+import type { Kinds } from "./bindings";
+export type Site = {
+    element: string;
+    line: number;
+};
+export type SlotReport = {
+    slots: number;
+    kept: Site[];
+    unhandled: Site[];
+    forwarders: string[];
+};
+export declare const SLOT_NOTE = "/* fjsf-v3-codemod: slots get the library component as `Default`; a wrapper that rendered the 2.x component renders <props.Default {...props} /> */";
+export declare const rewriteSlots: (source: string, report: SlotReport, kinds: Kinds) => string;

package/dist/types/v3/codemod/transform.d.ts

@@ -0,0 +1,29 @@
+import type { Kinds } from "./bindings";
+import type { SlotReport } from "./slots";
+export { PACKAGE } from "./package";
+/** I-1: an override-only (undefined) name; F-1: a Form class in a FormView styling file. A use can be both. */
+export type Inert = {
+    name: string;
+    line: number;
+    reasons: Array<"I-1" | "F-1">;
+};
+export type Report = SlotReport & {
+    selectors: number;
+    inert: Inert[];
+    unknown: string[];
+    imports: number;
+};
+/** A file that styles the library's FormView (pro3's FormView/styledComponents.tsx): imports FormView, not Form. */
+export declare const stylesFormView: (source: string) => boolean;
+/**
+ * `kinds`: what each name in this file is (from resolveKinds over all files); without it, only this file's own
+ * declarations count. `wrappers`: elements that pass their props to Form / FormView (`--wrappers`).
+ */
+export type TransformOptions = {
+    kinds?: Kinds;
+    wrappers?: readonly string[];
+};
+export declare const transform: (source: string, options?: TransformOptions) => {
+    output: string;
+    report: Report;
+};

package/dist/types/v3/document/fromDocument.d.ts

@@ -0,0 +1,22 @@
+import type { IssueSink } from "../raw/core/issues";
+import type { Schema } from "../raw/core/json";
+import type { ViewOptions } from "../raw/model/view/types";
+export type FjsfDocument = {
+    schema: Schema;
+    uiSchema?: Record<string, unknown>;
+    /** The values to show (what Formik held in the form). */
+    data?: unknown;
+    /** 2.x `formLocalization` (boolean labels and so on). */
+    formLocalization?: ViewOptions["formLocalization"];
+    /** Field names the host renders itself (pro3's custom fields); RAW renders an empty slot for them. */
+    customFields?: string[];
+    fileUploadView?: ViewOptions["fileUploadView"];
+};
+/** What the RAW view takes: `renderViewToString(schema, uiSchema, values, options)`. */
+export type DocumentParts = {
+    schema: Schema;
+    uiSchema: Record<string, unknown>;
+    values: unknown;
+    options: ViewOptions;
+};
+export declare const fromDocument: (input: unknown, sink?: IssueSink) => DocumentParts;

package/dist/types/v3/document/index.d.ts

@@ -0,0 +1,4 @@
+export { fromDocument } from "./fromDocument";
+export type { DocumentParts, FjsfDocument } from "./fromDocument";
+export { renderDocumentToString } from "./render";
+export type { RenderDocumentOptions } from "./render";

package/dist/types/v3/document/render.d.ts

@@ -0,0 +1,11 @@
+import type { IssueSink } from "../raw/core/issues";
+export type RenderDocumentOptions = {
+    /** Receives issue codes (REF_CYCLE, KEY_REJECTED, DOCUMENT_INVALID, ...). */
+    sink?: IssueSink;
+    /**
+     * The CSS to inline before the form, as a string or a function returning one, e.g. `getDefaultStyles` (S7). The PDF
+     * path has no style collection of its own, so the caller inlines the library CSS before its own `customCss`.
+     */
+    styles?: string | (() => string);
+};
+export declare const renderDocumentToString: (input: unknown, options?: RenderDocumentOptions) => string;

package/dist/types/v3/raw/compat/v2utils.d.ts

@@ -0,0 +1,14 @@
+import { getSchemaType, guessType } from "../core/schemaType";
+export declare const isObject: (object: unknown) => object is object;
+export declare const getDefaultValueForType: (type: import("..").Schema["type"]) => unknown;
+export { getSchemaType, guessType };
+export { createInitialValues } from "../core/initialValues";
+export type { InitialValuesType } from "../core/initialValues";
+export { createValidationSchema } from "../validation";
+export type { LocalizeType } from "../validation";
+export { hasReferences, solveReferences } from "../core/refs";
+export { mergeSchemas } from "../core/merge";
+export { deepOverlap, resolveOneOfValue, resolveSchema } from "../core/conditionals";
+export { extractUiSchema, getDescription, getHiddenProperties, getTitle, orderAdditionalProperties, orderByUiSchema } from "../core/uiSchema";
+export { EnumsTypes, getEnums, getSelectedEnum } from "../core/enums";
+export { immutablySwapItems, setTitleValues } from "../core/titles";

package/dist/types/v3/raw/core/arrays.d.ts

@@ -0,0 +1,22 @@
+import type { Schema } from "./json";
+import type { IssueSink } from "./issues";
+export type NormalisedArray = {
+    /** Fixed positions of a real tuple (`items: [...]`): no add/remove/move on these. */
+    fixed: Schema[];
+    /** Schema of every further item; undefined means no items can be added. */
+    tail: Schema | undefined;
+    /** N-1: the single `items` object that was ignored in favour of `additionalItems`. */
+    placeholder?: Schema;
+};
+export declare const normalizeArraySchema: (schema: Schema, sink?: IssueSink, path?: string) => NormalisedArray;
+/** True when a stored value's JSON type cannot be an instance of the schema's type. */
+export declare const valueTypeMismatch: (value: unknown, schema: Schema | undefined) => boolean;
+export type ItemSchema = {
+    schema: Schema | undefined;
+    /** N-1 value guard: render read-only, never rewrite, validate against `items` (§6.3). */
+    guarded: boolean;
+    /** Position is part of a real tuple. */
+    fixed: boolean;
+};
+/** Schema used for item `index`, given the stored value of that item. */
+export declare const itemSchema: (norm: NormalisedArray, index: number, value?: unknown) => ItemSchema;

package/dist/types/v3/raw/core/choiceStyle.d.ts

@@ -0,0 +1,4 @@
+/** The container's style attribute for a layout keyword, or nothing. */
+export declare const choiceStyle: (style: unknown) => {
+    style?: string;
+};

package/dist/types/v3/raw/core/conditionals.d.ts

@@ -0,0 +1,6 @@
+import type { Schema, SchemaDefinition } from "./json";
+/** 2.x deepOverlap: every key of `a` is present in `b` with an equal (or overlapping) value. */
+export declare const deepOverlap: (a: any, b: any) => boolean;
+export declare function resolveOneOfValue(value: SchemaDefinition | undefined): unknown;
+/** Same contract as 2.x resolveSchema: `[resolvedSchema, keysToPrune]`. */
+export declare const resolveSchema: (input: Schema, rawValue: unknown) => [Schema, string[]];

package/dist/types/v3/raw/core/dates.d.ts

@@ -0,0 +1,8 @@
+export type PreferOrder = "DMY" | "MDY";
+export declare const toIsoDateString: (date: Date) => string;
+export declare const isValidYMD: (y: number, m: number, d: number) => boolean;
+export declare const parseDateString: (input: string, preferOrder: PreferOrder) => Date | undefined;
+/** The day/month order of the locale's date format. */
+export declare const preferOrderOf: (locale: string) => PreferOrder;
+/** What the display input shows for a stored value (2.x formatForDisplay; `"now"` shows today). */
+export declare const formatForDisplay: (iso: unknown, locale: string, now?: Date) => string;

package/dist/types/v3/raw/core/defaults.d.ts

@@ -0,0 +1,15 @@
+import type { Schema } from "./json";
+/** Today's date as YYYY-MM-DD in local time (Q-DATE-1: 2.x used the UTC date). */
+export declare const localIsoDate: (now?: Date) => string;
+/** A value the user has not given yet: v3 applies defaults to these only. */
+export declare const isUnset: (value: unknown) => boolean;
+export type DefaultOptions = {
+    /** The item was created by "add" (2.x forceDefaultValue): fill `[]`/`{}` for containers. */
+    forceDefaultValue?: boolean;
+    now?: Date;
+};
+/**
+ * The value a field should get on appearance, or `undefined` for "leave it".
+ * Never overwrites a set value, honours `0`/`false` defaults.
+ */
+export declare const defaultFor: (schema: Schema, current: unknown, options?: DefaultOptions) => unknown;

package/dist/types/v3/raw/core/enums.d.ts

@@ -0,0 +1,18 @@
+import type { Schema } from "./json";
+import type { IssueSink } from "./issues";
+export declare enum EnumsTypes {
+    SELECT = "select",
+    MULTI_SELECT = "multiSelect"
+}
+export type EnumOption = {
+    const: any;
+    title: string;
+};
+export type Enums = {
+    type?: EnumsTypes;
+    values: EnumOption[];
+};
+export declare const getEnums: ({ schema }: {
+    schema?: Schema;
+}, sink?: IssueSink, path?: string) => Enums | undefined;
+export declare const getSelectedEnum: (selected: unknown, enums: Enums | undefined) => EnumOption[] | undefined;

package/dist/types/v3/raw/core/initialValues.d.ts

@@ -0,0 +1,12 @@
+import type { Definitions, Schema } from "./json";
+import type { IssueSink } from "./issues";
+import type { OptionalNumberInitial } from "./policies/optionalNumberInitial";
+export type InitialValuesType = {
+    [key: string]: unknown;
+};
+export type InitialValuesOptions = {
+    sink?: IssueSink;
+    /** Overrides the Q16 policy constant (tests, or a consumer that needs 2.x output). */
+    optionalNumberInitial?: OptionalNumberInitial;
+};
+export declare function createInitialValues(schema: Schema, definitions?: Definitions | Schema, options?: InitialValuesOptions): InitialValuesType;

package/dist/types/v3/raw/core/issues.d.ts

@@ -0,0 +1,17 @@
+export declare const ISSUE_CODES: readonly ["SCHEMA_UNSUPPORTED_TYPE", "SCHEMA_MISSING_TYPE", "SCHEMA_ARRAY_AMBIGUOUS", "SCHEMA_ENUM_CONFLICT", "REF_UNSUPPORTED", "REF_NOT_FOUND", "REF_CYCLE", "REF_DEPTH_EXCEEDED", "PATTERN_INVALID", "PATTERN_REJECTED", "PROP_REJECTED", "KEY_REJECTED", "KEY_AMBIGUOUS", "FIELD_UNKNOWN", "TEMPLATE_UNKNOWN", "TEMPLATE_DISABLED", "DOCUMENT_INVALID", "SANITIZER_UNAVAILABLE"];
+export type IssueCode = (typeof ISSUE_CODES)[number];
+export type Issue = {
+    code: IssueCode;
+    severity: "error" | "warning";
+    path?: string;
+    detail?: string;
+};
+export type IssueSink = (issue: Issue) => void;
+/** Default sink: drops issues. Pure functions take an optional sink. */
+export declare const ignoreIssues: IssueSink;
+export declare const issue: (code: IssueCode, path?: string, detail?: string) => Issue;
+/** Collects issues into an array (tests and the controller use this). */
+export declare const collectIssues: () => {
+    sink: IssueSink;
+    issues: Issue[];
+};

package/dist/types/v3/raw/core/json.d.ts

@@ -0,0 +1,52 @@
+import type { JSONSchema7, JSONSchema7Definition, JSONSchema7TypeName } from "json-schema";
+export type Schema = JSONSchema7;
+export type SchemaDefinition = JSONSchema7Definition;
+export type SchemaTypeName = JSONSchema7TypeName;
+export type Definitions = {
+    [key: string]: SchemaDefinition;
+} | undefined;
+/** JSON-serialisable uiSchema (v3 §3.2). The React layer widens TText/TField. */
+export type UiSchemaOf<TText, TField> = {
+    definitions?: {
+        [key: string]: UiSchemaOf<TText, TField>;
+    };
+    "ui:title"?: TText;
+    "ui:description"?: TText;
+    "ui:help"?: TText;
+    "ui:field"?: TField | string;
+    "ui:template"?: string;
+    "ui:options"?: {
+        [key: string]: any;
+    };
+    "ui:props"?: {
+        [key: string]: any;
+    };
+    "ui:order"?: UiOrderEntry[];
+    props?: {
+        [key: string]: any;
+    };
+} & {
+    [key: string]: any;
+};
+export type UiOrderEntry = string | {
+    title: string;
+    fields: string[];
+    collapsible?: boolean;
+};
+export type JsonUiSchema = UiSchemaOf<string, never>;
+/** Keys that must never be read or written as data/schema keys (SEC-8, SEC-10). */
+export declare const PROTOTYPE_KEYS: ReadonlySet<string>;
+export declare const hasOwn: (value: unknown, key: string) => boolean;
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export declare const isSchemaObject: (value: unknown) => value is Schema;
+/** JSON type name of a runtime value ("integer" is reported as "number"). */
+export declare const jsonTypeOf: (value: unknown) => SchemaTypeName | "undefined";
+/** Own enumerable keys, skipping prototype keys; [] for anything that is not an object. */
+export declare const safeKeys: (value: unknown) => string[];
+/** Structural equality for JSON values (used by uniqueItems, Q-VAL-6). */
+export declare const deepEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * How many levels of schema nesting (object schemas inside `properties`) the RAW core follows before it stops with
+ * REF_DEPTH_EXCEEDED. Real forms nest a handful of levels; this only bounds hostile or generated input (BUG-110).
+ */
+export declare const MAX_SCHEMA_DEPTH = 128;

package/dist/types/v3/raw/core/merge.d.ts

@@ -0,0 +1,6 @@
+import type { IssueSink } from "./issues";
+/**
+ * Never overflows the stack (BUG-110, Q-PP-3): a pair of objects that contains itself is cut with REF_CYCLE, nesting
+ * deeper than the limit with REF_DEPTH_EXCEEDED. The cut value is `{}`, so the result is always acyclic.
+ */
+export declare const mergeSchemas: (left: any, right: any, sink?: IssueSink) => any;

package/dist/types/v3/raw/core/paths.d.ts

@@ -0,0 +1,17 @@
+export type Segment = string | number;
+export type Path = Segment[];
+/** Splits a Formik/lodash path string: `a.b[0].c` -> ["a", "b", 0, "c"]. */
+export declare const toPath: (path: string | Path) => Path;
+/** Formik string form of a path: ["a", 0, "b"] -> "a[0].b"; root is "". */
+export declare const toFormikPath: (path: Path) => string;
+export declare const isPrototypeKey: (key: string) => boolean;
+/** A key the Formik string form cannot address without changing its meaning (Q-FMK-4). */
+export declare const isAmbiguousKey: (key: string) => boolean;
+/** Reads a value; undefined when any step is missing, wrong-typed or a prototype key. */
+export declare const getIn: (value: unknown, path: string | Path) => unknown;
+/**
+ * Immutable write. Returns the original value unchanged when the path contains a
+ * prototype key (the caller reports KEY_REJECTED). Wrong-typed intermediate values
+ * are replaced by a fresh container, like Formik's setIn.
+ */
+export declare const setIn: <T>(value: T, path: string | Path, next: unknown) => T;

package/dist/types/v3/raw/core/policies/fileUploadView.d.ts

@@ -0,0 +1,2 @@
+export type FileUploadView = "todo" | "hide";
+export declare const FILE_UPLOAD_VIEW: FileUploadView;

package/dist/types/v3/raw/core/policies/optionalNumberInitial.d.ts

@@ -0,0 +1,4 @@
+export type OptionalNumberInitial = "absent" | "empty" | "zero";
+export declare const OPTIONAL_NUMBER_INITIAL: OptionalNumberInitial;
+/** `undefined` means "leave the key out". */
+export declare const optionalNumberInitialValue: (policy?: OptionalNumberInitial) => 0 | "" | undefined;

package/dist/types/v3/raw/core/policies/storedFormats.d.ts

@@ -0,0 +1,4 @@
+export type MultiSelectStorage = "strings" | "consts";
+export type BooleanRadioStorage = "strings" | "booleans";
+export declare const MULTI_SELECT_STORAGE: MultiSelectStorage;
+export declare const BOOLEAN_RADIO_STORAGE: BooleanRadioStorage;

package/dist/types/v3/raw/core/refs.d.ts

@@ -0,0 +1,41 @@
+import type { Definitions, Schema } from "./json";
+import type { IssueSink } from "./issues";
+/** Maximum alias hops / nested expansions of the same chain (plan §5.2 SEC-9). */
+export declare const MAX_REF_DEPTH = 32;
+export type RefContext = {
+    /** Root `definitions` (2.x) */
+    definitions?: Definitions;
+    /** Root `$defs` (2019-09+) */
+    defs?: Definitions;
+    uiSchemaDefinitions?: {
+        [key: string]: any;
+    };
+    sink?: IssueSink;
+    /** Path of the node being resolved, for issue reports. */
+    path?: string;
+};
+type Pointer = {
+    root: "definitions" | "$defs";
+    segments: string[];
+} | undefined;
+/** Parses `#/definitions/a~1b` style pointers; undefined for anything else. */
+export declare const parseRef: (ref: string) => Pointer;
+export type Resolved = {
+    schema: Schema;
+    uiSchema: any;
+};
+/**
+ * Resolves the `$ref` of one schema node. Never throws: unsupported, missing,
+ * cyclic or too deep references produce an issue and a schema without `$ref`.
+ */
+export declare const resolveRefs: (schema: Schema, uiSchema: any, ctx: RefContext) => Resolved;
+/**
+ * 2.x-compatible signature (src/utils/solveReferences.ts): `definitions` is the
+ * root `definitions`. `$defs` is read from the same object when given via ctx.
+ */
+export declare const solveReferences: (schema: Schema, definitions: Definitions, uiSchema: any, uiSchemaDefinitions: {
+    [key: string]: any;
+} | undefined, options?: Omit<RefContext, "definitions" | "uiSchemaDefinitions">) => Resolved;
+/** Q-REF-5 (kept, documented): only `properties` are inspected. Cycle-safe (Q-PP-3). */
+export declare const hasReferences: (schema: Schema, seen?: Set<unknown>) => boolean;
+export {};

package/dist/types/v3/raw/core/schemaType.d.ts

@@ -0,0 +1,16 @@
+import type { Schema, SchemaTypeName } from "./json";
+export type NormalisedType = {
+    type: SchemaTypeName | "any";
+    nullable: boolean;
+};
+/** Same answer as 2.x getTypes.getSchemaType for every input 2.x accepted. */
+export declare const getSchemaType: (schema: Schema | undefined) => Schema["type"] | undefined;
+/** 2.x guessType (getTypes.ts), unchanged: used for `const` type guessing. */
+export declare const guessType: (value: any) => SchemaTypeName;
+/**
+ * v3 normalisation used by initial values and validation: always one type plus a
+ * nullable flag; "any" when nothing can be inferred (never a throw).
+ */
+export declare const normaliseType: (schema: Schema | undefined) => NormalisedType;
+/** Default value used when an item or property is created (2.x getDefaultValueForType). */
+export declare const defaultValueForType: (type: Schema["type"]) => unknown;

package/dist/types/v3/raw/core/titles.d.ts

@@ -0,0 +1,2 @@
+export declare const setTitleValues: (name: string, title: string, defaultTitle: string, values: unknown) => string;
+export declare function immutablySwapItems<T>(items: T[], firstIndex: number, secondIndex: number): T[];

package/dist/types/v3/raw/core/trail.d.ts

@@ -0,0 +1,5 @@
+import type { IssueSink } from "./issues";
+/** The object schemas being expanded above the current one, outermost first. */
+export type Trail = readonly object[];
+/** True when `node` may be expanded below `trail`; otherwise reports REF_CYCLE or REF_DEPTH_EXCEEDED and returns false. */
+export declare const mayEnter: (node: object, trail: Trail, sink: IssueSink, path: string) => boolean;

package/dist/types/v3/raw/core/uiProps.d.ts

@@ -0,0 +1,12 @@
+import type { IssueSink } from "./issues";
+/**
+ * Style properties (camelCase) allowed in `style`: typography, colour, box and flex/grid layout.
+ * Not allowed: positioning (`position`, `inset`, `top`..., `zIndex`), `background(-image)`,
+ * `content`, `transform`, `filter`, anything with `url(`, `expression(` or `javascript:` (provisional).
+ */
+export declare const STYLE_PROPERTIES: Set<string>;
+/** `{attrs, rejected}`: HTML attributes for a library element; rejected keys are reported on `sink`. */
+export declare const filterUiProps: (uiProps: unknown, path?: string, sink?: IssueSink) => {
+    attrs: Record<string, string | number | boolean>;
+    rejected: string[];
+};

package/dist/types/v3/raw/core/uiSchema.d.ts

@@ -0,0 +1,19 @@
+import type { Schema, UiOrderEntry } from "./json";
+/** Flattens `ui:*` keys (prefix removed) and `ui:options` into one object (2.x semantics). */
+export declare const extractUiSchema: (ui?: any) => {
+    [name: string]: any;
+};
+export declare const getHiddenProperties: (order: UiOrderEntry[] | undefined, properties: string[]) => string[];
+export declare function orderByUiSchema(order: UiOrderEntry[] | undefined, allProperties: string[]): UiOrderEntry[];
+export declare function orderAdditionalProperties(order: UiOrderEntry[] | undefined, values: string[]): string[];
+export declare const getTitle: ({ title, uiSchema, schema, name }: {
+    title?: any;
+    uiSchema?: any;
+    schema?: Schema;
+    name?: string;
+}) => any;
+export declare const getDescription: ({ description, uiSchema, schema }: {
+    description?: any;
+    uiSchema?: any;
+    schema?: Schema;
+}) => any;

package/dist/types/v3/raw/dom/bind.d.ts

@@ -0,0 +1,2 @@
+import type { Core } from "./core";
+export declare const bindEvents: (core: Core, target: HTMLElement) => () => void;

package/dist/types/v3/raw/dom/build.d.ts

@@ -0,0 +1,10 @@
+import type { IssueSink } from "../core/issues";
+import type { FormBuildContext, FormUiState } from "../model/form";
+import type { VNode } from "../model/vnode";
+import type { FormState } from "../store/createStore";
+import type { ControllerOptions } from "./types";
+export type Built = {
+    tree: VNode;
+    ctx?: FormBuildContext;
+};
+export declare const buildTree: (schema: any, uiSchema: any, state: FormState, ui: FormUiState, o: ControllerOptions, sink: IssueSink) => Built;