@json-layout/core 2.8.0 → 2.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-layout/core",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "Compilation and state management utilities for JSON Layout.",
   "type": "module",
   "exports": {
@@ -82,7 +82,7 @@
   },
   "homepage": "https://github.com/json-layout/json-layout#readme",
   "peerDependencies": {
-    "@json-layout/vocabulary": "^2.13.0"
+    "@json-layout/vocabulary": "^2.13.1"
   },
   "dependencies": {
     "ajv": "^8.17.1",

package/src/compile/serialize.js

@@ -51,6 +51,8 @@ export async function serialize (compiledLayout) {
   let code = standaloneCode.default(ajv, validatesExports)
 
   code = code.replace('"use strict";', '')
+  // make the exportN validates module-local so the object below can reference them
+  code = code.replace(/export const (export\d+) =/g, 'const $1 =')
 
   // some internal imports to ajv are not translated to esm, we do it here
   // cf https://github.com/ajv-validator/ajv-formats/pull/73
@@ -76,8 +78,7 @@ export async function serialize (compiledLayout) {
     ajvI18nPath = 'ajv-i18n/localize/en/index.js'
   }
 
-  code = `import localizeErrors from "${ajvI18nPath}";
-export const exportLocalizeErrors = localizeErrors;\n` + code
+  code = `import localizeErrors from "${ajvI18nPath}";\n` + code
 
   i = 0
   const expressionsNodes = []
@@ -91,30 +92,32 @@ export const exportLocalizeErrors = localizeErrors;\n` + code
     expressionsNodes.push(builders.raw(id))
   }
 
-  const ast = parseModule(code)
+  // reference the validate functions by name, keyed by json-pointer
+  /** @type {Record<string, any>} */
+  const validatesNodes = {}
+  i = 0
+  for (const pointer of Object.keys(compiledLayout.validates)) {
+    validatesNodes[pointer] = builders.raw(`export${i++}`)
+  }
+
+  // run magicast only on the small object literal; keep the large generated `code` as
+  // a raw string prefix (parsing it was the serialization bottleneck)
+  const ast = parseModule('export const compiledLayout = {}')
   ast.exports.compiledLayout = {
     mainTree: compiledLayout.mainTree,
     skeletonTrees: clone(compiledLayout.skeletonTrees),
     skeletonNodes: clone(compiledLayout.skeletonNodes),
     normalizedLayouts: clone(compiledLayout.normalizedLayouts),
-    validates: {},
+    validates: validatesNodes,
     validationErrors: compiledLayout.validationErrors,
     expressions: expressionsNodes,
     locale: compiledLayout.locale,
     messages: compiledLayout.messages,
     components: compiledLayout.options.components,
-    localizeErrors: ast.exports.exportLocalizeErrors
-  }
-  delete ast.exports.exportLocalizeErrors
-
-  i = 0
-  for (const pointer of Object.keys(compiledLayout.validates)) {
-    const exportKey = `export${i++}`
-    ast.exports.compiledLayout.validates[pointer] = ast.exports[exportKey]
-    delete ast.exports[exportKey]
+    localizeErrors: builders.raw('localizeErrors')
   }
 
-  const generatedCode = generateCode(ast).code.replace('export const compiledLayout = {', 'const compiledLayout = {')
+  const objectCode = generateCode(ast).code.replace('export const compiledLayout = {', 'const compiledLayout = {')
 
-  return generatedCode
+  return `${code}\n${objectCode}`
 }

package/src/compile/skeleton-node.js

@@ -305,6 +305,7 @@ export function makeSkeletonNode (
       /** @type {string | undefined} */
       let discriminator
       if (schema.discriminator?.propertyName) discriminator = schema.discriminator?.propertyName
+      else discriminator = inferDiscriminator(schema.oneOf, schemaId, getJSONRef)
       const oneOfPointer = `${refPointerPrefix}/oneOf`
       if (!normalizedLayouts[oneOfPointer]) {
         const normalizationResult = normalizeLayoutFragment(
@@ -594,3 +595,27 @@ export function makeSkeletonNode (
 
   return node
 }
+
+/**
+ * infer a discriminator when the keyword was not declared:
+ * a property that has a distinct const string value in every branch of the oneOf
+ * @param {any[]} oneOf
+ * @param {string} schemaId
+ * @param {(schemaId: string, ref: string) => [any, string, string]} getJSONRef
+ * @returns {string | undefined}
+ */
+function inferDiscriminator (oneOf, schemaId, getJSONRef) {
+  const fragments = oneOf.map(branch => branch.$ref ? getJSONRef(schemaId, branch.$ref)[0] : branch)
+  const candidateKeys = Object.keys(fragments[0]?.properties ?? {})
+  for (const key of candidateKeys) {
+    /** @type {string[]} */
+    const values = []
+    const distinct = fragments.every(fragment => {
+      const value = fragment?.properties?.[key]?.const
+      if (typeof value !== 'string' || values.includes(value)) return false
+      values.push(value)
+      return true
+    })
+    if (distinct) return key
+  }
+}

package/src/i18n/de.js

@@ -8,6 +8,7 @@ export default {
   confirm: 'Bestätigen',
   close: 'Schließen',
   duplicate: 'Duplizieren',
+  insertAfter: 'Danach einfügen',
   copy: 'Kopie',
   paste: 'Paste',
   sort: 'Sortieren',

package/src/i18n/en.js

@@ -8,6 +8,7 @@ export default {
   confirm: 'Confirm',
   close: 'Close',
   duplicate: 'Duplicate',
+  insertAfter: 'Insert after',
   copy: 'Copy',
   paste: 'Paste',
   sort: 'Sort',

package/src/i18n/fr.js

@@ -8,6 +8,7 @@ export default {
   confirm: 'Confirmer',
   close: 'Fermer',
   duplicate: 'Dupliquer',
+  insertAfter: 'Insérer après',
   copy: 'Copier',
   paste: 'Coller',
   sort: 'Trier',

package/src/i18n/nl.js

@@ -8,6 +8,7 @@ export default {
   edit: 'Bewerken',
   close: 'Sluiten',
   duplicate: 'Verveelvoudigen',
+  insertAfter: 'Hierna invoegen',
   copy: 'Kopiëren',
   paste: 'Plakken',
   sort: 'Sorteren',

package/src/i18n/types.ts

@@ -12,6 +12,7 @@ export interface StateOptionsMessages {
   edit: string
   close: string
   duplicate: string
+  insertAfter: string
   copy: string
   paste: string
   sort: string

package/src/state/index.js

@@ -139,6 +139,10 @@ export class StatefulLayout {
   set data (data) {
     logDataBinding('apply main data setter', data)
     this._data = data
+    // data replaced from outside is authoritative, previously activated oneOf branches
+    // are re-resolved from the new data (discriminator based or validation based)
+    this._explicitActivatedItems.clear()
+    this._reResolveActivatedItems = true
     this.updateState()
   }
 
@@ -285,6 +289,10 @@ export class StatefulLayout {
     /** @type {CreateStateTreeContext} */
     const createStateTreeContext = {
       activatedItems: this.activatedItems,
+      explicitActivatedItems: this._explicitActivatedItems,
+      // only the first tree creation after the data setter re-resolves activated branches,
+      // the following hydration iterations preserve them so that they cannot oscillate
+      reResolveActivatedItems: this._reResolveActivatedItems,
       autoActivatedItems: {},
       autofocusTarget: this._autofocusTarget,
       currentInput: this._currentInput,
@@ -303,6 +311,8 @@ export class StatefulLayout {
     // @ts-ignore
     if (this._options._debugCache) createStateTreeContext._debugCache = this._lastCreateStateTreeContext?._debugCache ?? {}
 
+    this._reResolveActivatedItems = false
+
     this._stateTree = createStateTree(
       createStateTreeContext,
       this._options,
@@ -453,6 +463,7 @@ export class StatefulLayout {
     if (activateKey !== undefined) {
       logActivatedItems(node.fullKey, 'activated item on input', activateKey)
       this.activatedItems = produce(this.activatedItems, draft => { draft[node.fullKey] = activateKey })
+      this._explicitActivatedItems.add(node.fullKey)
       this._autofocusTarget = node.fullKey + '/' + activateKey
     }
     if (node.parentFullKey === null) {
@@ -713,6 +724,21 @@ export class StatefulLayout {
    */
   activatedItems
 
+  /**
+   * keys of activatedItems that were explicitly selected by the user,
+   * as opposed to auto-activated from the data
+   * @private
+   * @type {Set<string>}
+   */
+  _explicitActivatedItems = new Set()
+
+  /**
+   * true after data was replaced from outside, consumed by the next state tree creation
+   * @private
+   * @type {boolean}
+   */
+  _reResolveActivatedItems = false
+
   /**
    * @param {StateNode} node
    * @param {number | string} key
@@ -720,6 +746,7 @@ export class StatefulLayout {
   activateItem (node, key) {
     logActivatedItems(node.fullKey, 'activate item explicitly', key)
     this.activatedItems = produce(this.activatedItems, draft => { draft[node.fullKey] = key })
+    this._explicitActivatedItems.add(node.fullKey)
     this._autofocusTarget = node.fullKey + '/' + key
     if (node.key === '$oneOf') {
       if (node.layout.emptyData && node.data && typeof node.data === 'object' && node.children?.[0]) {
@@ -764,6 +791,7 @@ export class StatefulLayout {
         if (key.startsWith(node.fullKey)) {
           logActivatedItems(node.fullKey, 'item deactivation deletes a key', key)
           delete draft[key]
+          this._explicitActivatedItems.delete(key)
         }
       }
     })

package/src/state/state-node.js

@@ -570,13 +570,34 @@ export function createStateNode (
     // find the oneOf child that was either previously selected
     // or the one matching the specified discriminator
     // or the one that is valid with current data
-    let activeChildTreeIndex = /** @type {number} */(context.activatedItems[fullKey])
+    let activeChildTreeIndex = /** @type {number | undefined} */(context.activatedItems[fullKey])
     let validChildTreeIndex = -1
+    if (
+      activeChildTreeIndex !== undefined &&
+      skeleton.discriminator !== undefined &&
+      !context.explicitActivatedItems.has(fullKey) &&
+      data?.[skeleton.discriminator] !== undefined
+    ) {
+      // an auto-activated branch is only kept as long as the discriminator value in the data still matches it,
+      // so that data replaced from outside (main data setter) is re-resolved to the right branch
+      const activeTree = skeleton.childrenTrees[activeChildTreeIndex]
+      if (activeTree !== undefined && compiledLayout.skeletonTrees[activeTree].discriminatorValue !== data[skeleton.discriminator]) {
+        activeChildTreeIndex = undefined
+      }
+    }
     if (activeChildTreeIndex !== undefined) {
-      // already explicitly activated, just check if data validates against the active variant
+      // already activated, just check if data validates against the active variant
       const activeTree = skeleton.childrenTrees[activeChildTreeIndex]
       if (activeTree !== undefined && compiledLayout.validates[compiledLayout.skeletonTrees[activeTree].refPointer](data)) {
         validChildTreeIndex = activeChildTreeIndex
+      } else if (context.reResolveActivatedItems) {
+        // data was replaced from outside (main data setter) and does not validate against the active branch,
+        // switch to another branch that validates the new data, keep the active branch if none does
+        const reResolvedIndex = skeleton.childrenTrees.findIndex((childTree) => compiledLayout.validates[compiledLayout.skeletonTrees[childTree].refPointer](data))
+        if (reResolvedIndex !== -1) {
+          activeChildTreeIndex = reResolvedIndex
+          validChildTreeIndex = reResolvedIndex
+        }
       }
     } else {
       // try discriminator-based resolution first (cheap string comparison)
@@ -599,7 +620,8 @@ export function createStateNode (
     if (activeChildTreeIndex !== -1) {
       const activeChildTree = compiledLayout.skeletonTrees[skeleton.childrenTrees[activeChildTreeIndex]]
       const activeChildNode = compiledLayout.skeletonNodes[activeChildTree.root]
-      if (!(fullKey in context.activatedItems)) context.autoActivatedItems[fullKey] = activeChildTreeIndex
+      // record the auto-activated branch, also when it changed compared to a stale previously activated branch
+      if (context.activatedItems[fullKey] !== activeChildTreeIndex) context.autoActivatedItems[fullKey] = activeChildTreeIndex
       context.errors = context.errors?.filter(error => {
         // if an item was selected, remove the oneOf error
         if (matchLocalError(error, skeleton, dataPath, parentDataPath)) {

package/src/state/types.ts

@@ -73,6 +73,12 @@ export interface CreateStateTreeContext {
   additionalPropertiesErrors?: ErrorObject[]
   files: FileRef[]
   activatedItems: Record<string, number | string>
+  // keys of activatedItems that were explicitly selected by the user (activateItem / input with activateKey)
+  // as opposed to auto-activated from the data, they are not challenged by the discriminator value in the data
+  explicitActivatedItems: Set<string>
+  // true on the first state tree creation after data was replaced from outside (main data setter),
+  // activated oneOf branches that do not validate the new data are then re-resolved
+  reResolveActivatedItems: boolean
   autoActivatedItems: Record<string, number | number>
   autofocusTarget: string | null
   currentInput: string | null

package/types/compile/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {object} _schema
+ * @param {PartialCompileOptions} [partialOptions]
+ * @returns {CompiledLayout}
+ */
+export function compile(_schema: object, partialOptions?: PartialCompileOptions): CompiledLayout;
+export { resolveLocaleRefs } from "./utils/resolve-refs.js";
+export { resolveXI18n } from "./utils/x-i18n.js";
+export { produceCompileOptions } from "./options.js";
+export type SkeletonTree = import("./types.js").SkeletonTree;
+export type SkeletonNode = import("./types.js").SkeletonNode;
+export type CompiledLayout = import("./types.js").CompiledLayout;
+export type CompileOptions = import("./types.js").CompileOptions;
+export type PartialCompileOptions = import("./types.js").PartialCompileOptions;
+export type CompiledExpression = import("./types.js").CompiledExpression;
+//# sourceMappingURL=index.d.ts.map

package/types/compile/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compile/index.js"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,iCAJW,MAAM,mBACN,qBAAqB,GACnB,cAAc,CAuH1B;;;;2BAvIY,OAAO,YAAY,EAAE,YAAY;2BACjC,OAAO,YAAY,EAAE,YAAY;6BACjC,OAAO,YAAY,EAAE,cAAc;6BACnC,OAAO,YAAY,EAAE,cAAc;oCACnC,OAAO,YAAY,EAAE,qBAAqB;iCAC1C,OAAO,YAAY,EAAE,kBAAkB"}

package/types/compile/options.d.ts

@@ -0,0 +1,6 @@
+export function fillOptions(partialOptions: PartialCompileOptions): CompileOptions;
+/** @type {(draft: PartialCompileOptions, newOptions: PartialCompileOptions) => PartialCompileOptions} */
+export const produceCompileOptions: (draft: PartialCompileOptions, newOptions: PartialCompileOptions) => PartialCompileOptions;
+export type CompileOptions = import("./types.js").CompileOptions;
+export type PartialCompileOptions = import("./types.js").PartialCompileOptions;
+//# sourceMappingURL=options.d.ts.map

package/types/compile/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/compile/options.js"],"names":[],"mappings":"AAqBO,4CAHI,qBAAqB,GACnB,cAAc,CAwD1B;AAGD,yGAAyG;AACzG,oCADW,CAAC,KAAK,EAAE,qBAAqB,EAAE,UAAU,EAAE,qBAAqB,KAAK,qBAAqB,CAiBnG;6BArFW,OAAO,YAAY,EAAE,cAAc;oCACnC,OAAO,YAAY,EAAE,qBAAqB"}

package/types/compile/serialize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {import('./index.js').CompiledLayout} compiledLayout
+ * @returns {Promise<string>}
+ */
+export function serialize(compiledLayout: import("./index.js").CompiledLayout): Promise<string>;
+//# sourceMappingURL=serialize.d.ts.map

package/types/compile/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/compile/serialize.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,0CAHW,OAAO,YAAY,EAAE,cAAc,GACjC,OAAO,CAAC,MAAM,CAAC,CA4G3B"}

package/types/compile/skeleton-node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {any} rawSchema
+ * @param {string} sourceSchemaId
+ * @param {import('./index.js').CompileOptions} options
+ * @param {(schemaId: string, ref: string) => [any, string, string]} getJSONRef
+ * @param {Record<string, import('./types.js').SkeletonTree>} skeletonTrees
+ * @param {Record<string, import('./types.js').SkeletonNode>} skeletonNodes
+ * @param {string[]} validatePointers
+ * @param {Record<string, string[]>} validationErrors
+ * @param {Record<string, import('@json-layout/vocabulary').NormalizedLayout>} normalizedLayouts
+ * @param {import('@json-layout/vocabulary').Expression[]} expressions
+ * @param {string | number} key
+ * @param {string} pointer
+ * @param {boolean} required
+ * @param {string} [condition]
+ * @param {boolean} [dependent]
+ * @param {string} [knownType]
+ * @returns {import('./types.js').SkeletonNode}
+ */
+export function makeSkeletonNode(rawSchema: any, sourceSchemaId: string, options: import("./index.js").CompileOptions, getJSONRef: (schemaId: string, ref: string) => [any, string, string], skeletonTrees: Record<string, import("./types.js").SkeletonTree>, skeletonNodes: Record<string, import("./types.js").SkeletonNode>, validatePointers: string[], validationErrors: Record<string, string[]>, normalizedLayouts: Record<string, import("@json-layout/vocabulary").NormalizedLayout>, expressions: import("@json-layout/vocabulary").Expression[], key: string | number, pointer: string, required: boolean, condition?: string, dependent?: boolean, knownType?: string): import("./types.js").SkeletonNode;
+//# sourceMappingURL=skeleton-node.d.ts.map

package/types/compile/skeleton-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton-node.d.ts","sourceRoot":"","sources":["../../src/compile/skeleton-node.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAlBW,GAAG,kBACH,MAAM,WACN,OAAO,YAAY,EAAE,cAAc,cACnC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,iBACxD,MAAM,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,YAAY,CAAC,iBACjD,MAAM,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,YAAY,CAAC,oBACjD,MAAM,EAAE,oBACR,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,qBACxB,MAAM,CAAC,MAAM,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAC,eAClE,OAAO,yBAAyB,EAAE,UAAU,EAAE,OAC9C,MAAM,GAAG,MAAM,WACf,MAAM,YACN,OAAO,cACP,MAAM,cACN,OAAO,cACP,MAAM,GACJ,OAAO,YAAY,EAAE,YAAY,CA6jB7C"}

package/types/compile/skeleton-tree.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {any} schema
+ * @param {string} schemaId
+ * @param {import('./index.js').CompileOptions} options
+ * @param {(schemaId: string, ref: string) => [any, string, string]} getJSONRef
+ * @param {Record<string, import('./types.js').SkeletonTree>} skeletonTrees
+ * @param {Record<string, import('./types.js').SkeletonNode>} skeletonNodes
+ * @param {string[]} validatePointers
+ * @param {Record<string, string[]>} validationErrors
+ * @param {Record<string, import('@json-layout/vocabulary').NormalizedLayout>} normalizedLayouts
+ * @param {import('@json-layout/vocabulary').Expression[]} expressions
+ * @param {string} pointer
+ * @param {string} [defaultTitle]
+ * @param {boolean} [deleteRootNodeTitle]
+ * @param {string} [discriminator]
+ * @returns {import('./types.js').SkeletonTree}
+ */
+export function makeSkeletonTree(schema: any, schemaId: string, options: import("./index.js").CompileOptions, getJSONRef: (schemaId: string, ref: string) => [any, string, string], skeletonTrees: Record<string, import("./types.js").SkeletonTree>, skeletonNodes: Record<string, import("./types.js").SkeletonNode>, validatePointers: string[], validationErrors: Record<string, string[]>, normalizedLayouts: Record<string, import("@json-layout/vocabulary").NormalizedLayout>, expressions: import("@json-layout/vocabulary").Expression[], pointer: string, defaultTitle?: string, deleteRootNodeTitle?: boolean, discriminator?: string): import("./types.js").SkeletonTree;
+//# sourceMappingURL=skeleton-tree.d.ts.map

package/types/compile/skeleton-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton-tree.d.ts","sourceRoot":"","sources":["../../src/compile/skeleton-tree.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,yCAhBW,GAAG,YACH,MAAM,WACN,OAAO,YAAY,EAAE,cAAc,cACnC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,iBACxD,MAAM,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,YAAY,CAAC,iBACjD,MAAM,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,YAAY,CAAC,oBACjD,MAAM,EAAE,oBACR,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,qBACxB,MAAM,CAAC,MAAM,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAC,eAClE,OAAO,yBAAyB,EAAE,UAAU,EAAE,WAC9C,MAAM,iBACN,MAAM,wBACN,OAAO,kBACP,MAAM,GACJ,OAAO,YAAY,EAAE,YAAY,CAqD7C"}

package/types/compile/types.d.ts

@@ -0,0 +1,61 @@
+import type ajvModule from 'ajv/dist/2019.js';
+import type { MarkedOptions } from 'marked';
+import { type ComponentInfo, type BaseCompObject, type NormalizedLayout, type StateNodeOptionsBase, type Expression, type NormalizeOptions } from '@json-layout/vocabulary';
+import { type ValidateFunction, type SchemaObject } from 'ajv/dist/2019.js';
+import { type Display } from '../state/utils/display.js';
+import { type LocaleMessages } from '../i18n/types.js';
+export interface ParentContextExpression {
+    data: unknown;
+    parent: ParentContextExpression | undefined | null;
+}
+export type CompiledExpression = (data: any, dataAlias: any, options: StateNodeOptionsBase, context: object, display: Display, layout: BaseCompObject, readOnly: boolean, summary: boolean, validates: Record<string, ValidateFunction>, rootData?: unknown, parent?: ParentContextExpression | null) => any;
+export type CompileOptions = NormalizeOptions & {
+    ajv: ajvModule.default;
+    ajvOptions?: ajvModule.Options;
+    markedOptions?: MarkedOptions;
+    locale: string;
+    defaultLocale: string;
+    messages: LocaleMessages;
+    xI18n: boolean;
+};
+export type PartialCompileOptions = Partial<Omit<CompileOptions, 'messages'>> & {
+    messages?: Partial<LocaleMessages>;
+    components?: Record<string, Omit<ComponentInfo, 'name'>>;
+};
+export interface CompiledLayout {
+    options?: CompileOptions;
+    schema?: SchemaObject;
+    mainTree: string;
+    skeletonTrees: Record<string, SkeletonTree>;
+    skeletonNodes: Record<string, SkeletonNode>;
+    validates: Record<string, ValidateFunction>;
+    validationErrors: Record<string, string[]>;
+    normalizedLayouts: Record<string, NormalizedLayout>;
+    expressions: CompiledExpression[];
+    locale: string;
+    messages: LocaleMessages;
+    components: Record<string, Omit<ComponentInfo, 'schema'>>;
+    localizeErrors: (errors: ajvModule.ErrorObject[]) => void;
+}
+export interface SkeletonTree {
+    title: string;
+    root: string;
+    refPointer: string;
+    discriminatorValue?: string;
+}
+export interface SkeletonNode {
+    title?: string;
+    key: string | number;
+    pointer: string;
+    refPointer: string;
+    pure: boolean;
+    propertyKeys: string[];
+    roPropertyKeys: string[];
+    condition?: Expression;
+    children?: string[];
+    childrenTrees?: string[];
+    discriminator?: string;
+    required?: boolean;
+    nullable?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/compile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/compile/types.ts"],"names":[],"mappings":"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"}

package/types/compile/utils/resolve-refs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * mutates a schema by replacing ~$locale~ in all refs
+ * @param {import('ajv').SchemaObject} schema
+ * @param {import('ajv/dist/2019.js').default} ajv
+ * @param {string} [locale]
+ * @param {string} [defaultLocale]
+ * @returns {(schemaId: string, ref: string) => [any, string, string]}
+ */
+export function resolveLocaleRefs(schema: import("ajv").SchemaObject, ajv: import("ajv/dist/2019.js").default, locale?: string, defaultLocale?: string): (schemaId: string, ref: string) => [any, string, string];
+/**
+ * partially resolve a schema but not recursively, used for layout normalization
+ * @param {import('ajv').SchemaObject} schema
+ * @param {string} schemaId
+ * @param {(schemaId: string, ref: string) => [any, string, string]} getJSONRef
+ */
+export function partialResolveRefs(schema: import("ajv").SchemaObject, schemaId: string, getJSONRef: (schemaId: string, ref: string) => [any, string, string]): any;
+//# sourceMappingURL=resolve-refs.d.ts.map

package/types/compile/utils/resolve-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-refs.d.ts","sourceRoot":"","sources":["../../../src/compile/utils/resolve-refs.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,0CANW,OAAO,KAAK,EAAE,YAAY,OAC1B,OAAO,kBAAkB,EAAE,OAAO,WAClC,MAAM,kBACN,MAAM,GACJ,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,CASpE;AAuCD;;;;;GAKG;AACH,2CAJW,OAAO,KAAK,EAAE,YAAY,YAC1B,MAAM,cACN,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,OA+ClE"}

package/types/compile/utils/x-i18n.d.ts

@@ -0,0 +1,2 @@
+export function resolveXI18n(schema: Record<string, any>, locale: string, defaultLocale?: string): void;
+//# sourceMappingURL=x-i18n.d.ts.map

package/types/compile/utils/x-i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-i18n.d.ts","sourceRoot":"","sources":["../../../src/compile/utils/x-i18n.js"],"names":[],"mappings":"AAOO,qCAJI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,UACnB,MAAM,kBACN,MAAM,QAkBhB"}

package/types/i18n/de.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    errorOneOf: string;
+    errorRequired: string;
+    addItem: string;
+    delete: string;
+    edit: string;
+    confirm: string;
+    close: string;
+    duplicate: string;
+    insertAfter: string;
+    copy: string;
+    paste: string;
+    sort: string;
+    up: string;
+    down: string;
+    showHelp: string;
+    default: string;
+    name: string;
+    examples: string;
+    deprecated: string;
+    keyboardDate: string;
+    keyboardDateTime: string;
+};
+export default _default;
+//# sourceMappingURL=de.d.ts.map

package/types/i18n/de.d.ts.map

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

package/types/i18n/en.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    errorOneOf: string;
+    errorRequired: string;
+    addItem: string;
+    delete: string;
+    edit: string;
+    confirm: string;
+    close: string;
+    duplicate: string;
+    insertAfter: string;
+    copy: string;
+    paste: string;
+    sort: string;
+    up: string;
+    down: string;
+    showHelp: string;
+    default: string;
+    name: string;
+    examples: string;
+    deprecated: string;
+    keyboardDate: string;
+    keyboardDateTime: string;
+};
+export default _default;
+//# sourceMappingURL=en.d.ts.map

package/types/i18n/en.d.ts.map

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

package/types/i18n/fr.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    errorOneOf: string;
+    errorRequired: string;
+    addItem: string;
+    delete: string;
+    edit: string;
+    confirm: string;
+    close: string;
+    duplicate: string;
+    insertAfter: string;
+    copy: string;
+    paste: string;
+    sort: string;
+    up: string;
+    down: string;
+    showHelp: string;
+    default: string;
+    name: string;
+    examples: string;
+    deprecated: string;
+    keyboardDate: string;
+    keyboardDateTime: string;
+};
+export default _default;
+//# sourceMappingURL=fr.d.ts.map

package/types/i18n/fr.d.ts.map

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

package/types/i18n/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    en: import("./types.js").LocaleMessages;
+    fr: import("./types.js").LocaleMessages;
+    nl: import("./types.js").LocaleMessages;
+    de: import("./types.js").LocaleMessages;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/types/i18n/index.d.ts.map

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

package/types/i18n/nl.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    errorOneOf: string;
+    errorRequired: string;
+    addItem: string;
+    delete: string;
+    confirm: string;
+    edit: string;
+    close: string;
+    duplicate: string;
+    insertAfter: string;
+    copy: string;
+    paste: string;
+    sort: string;
+    up: string;
+    down: string;
+    showHelp: string;
+    default: string;
+    name: string;
+    examples: string;
+    deprecated: string;
+    keyboardDate: string;
+    keyboardDateTime: string;
+};
+export default _default;
+//# sourceMappingURL=nl.d.ts.map

package/types/i18n/nl.d.ts.map

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