@json-layout/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 json-layout
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@json-layout/core",
+  "version": "0.1.0",
+  "description": "Compilation and state management utilities for JSON Layout.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./src/index.js",
+        "types": "./types/index.d.ts"
+      }
+    },
+    "./src/compile/serialize": {
+      "import": {
+        "default": "./src/compile/serialize.js",
+        "types": "./types/compile/serialize.d.ts"
+      }
+    }
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "scripts": {
+    "test:single": "node --no-experimental-fetch --test --test-only test/*.spec.js",
+    "test": "node --no-experimental-fetch --test test/*.spec.js",
+    "build": "rm -rf ./types && tsc -p tsconfig.build.json",
+    "lint": "eslint . --fix",
+    "watch:build": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
+    "watch:test": "node --no-experimental-fetch --test --watch test/*.spec.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/json-layout/json-layout.git"
+  },
+  "keywords": [
+    "json",
+    "schema",
+    "forms",
+    "layout"
+  ],
+  "author": "Alban Mouton <alban.mouton@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/json-layout/json-layout/issues"
+  },
+  "homepage": "https://github.com/json-layout/json-layout#readme",
+  "dependencies": {
+    "@json-layout/vocabulary": "^0.1.0",
+    "@types/markdown-it": "^13.0.1",
+    "ajv": "^8.12.0",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^2.1.1",
+    "ajv-i18n": "^4.2.0",
+    "debug": "^4.3.4",
+    "immer": "^10.0.3",
+    "magicast": "^0.3.0",
+    "markdown-it": "^13.0.2",
+    "mitt": "^3.0.1",
+    "recast": "^0.23.4",
+    "rfdc": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/node-fetch": "^2.6.5",
+    "json-schema-to-typescript": "^13.1.1",
+    "nock": "^13.3.3",
+    "node-fetch": "^2.7.0"
+  }
+}

package/src/compile/index.js

@@ -0,0 +1,136 @@
+// compileStatic is meant to produce a serializable result
+
+import ajvModule from 'ajv'
+import rfdc from 'rfdc'
+// import { Parser as ExprEvalParser } from 'expr-eval'
+import addFormats from 'ajv-formats'
+import ajvErrors from 'ajv-errors'
+import ajvLocalizeModule from 'ajv-i18n'
+import MarkdownIt from 'markdown-it'
+import i18n from '../i18n/index.js'
+import { makeSkeletonTree } from './skeleton-tree.js'
+import { resolveRefs } from './utils/resolve-refs.js'
+
+export { resolveRefs } from './utils/resolve-refs.js'
+
+/**
+ * @typedef {import('./types.js').SkeletonTree} SkeletonTree
+ * @typedef {import('./types.js').SkeletonNode} SkeletonNode
+ * @typedef {import('./types.js').CompiledLayout} CompiledLayout
+ * @typedef {import('./types.js').CompileOptions} CompileOptions
+ * @typedef {import('./types.js').PartialCompileOptions} PartialCompileOptions
+ * @typedef {import('./types.js').CompiledExpression} CompiledExpression
+ */
+
+// @ts-ignore
+const Ajv = /** @type {typeof ajvModule.default} */ (ajvModule)
+// @ts-ignore
+const ajvLocalize = /** @type {typeof ajvLocalizeModule.default} */ (ajvLocalizeModule)
+
+const expressionsParams = ['data', 'options', 'display']
+
+const clone = rfdc()
+// const exprEvalParser = new ExprEvalParser()
+
+/**
+ * @param {PartialCompileOptions} partialOptions
+ * @returns {CompileOptions}
+ */
+const fillOptions = (partialOptions) => {
+  let ajv = partialOptions.ajv
+  if (!ajv) {
+    /** @type {import('ajv').Options} */
+    const ajvOpts = { strict: false, allErrors: true }
+    if (partialOptions.code) ajvOpts.code = { source: true, esm: true, lines: true }
+    const newAjv = new Ajv(ajvOpts)
+    addFormats.default(newAjv)
+    ajvErrors.default(newAjv)
+    ajv = newAjv
+  }
+
+  let markdown = partialOptions.markdown
+  if (!markdown) {
+    const markdownIt = new MarkdownIt(partialOptions.markdownIt ?? {})
+    markdown = markdownIt.render.bind(markdownIt)
+  }
+
+  const locale = partialOptions.locale || 'en'
+  const messages = { ...i18n[locale] || i18n.en }
+  if (partialOptions.messages) Object.assign(messages, partialOptions.messages)
+
+  return {
+    ajv,
+    code: false,
+    markdown,
+    ...partialOptions,
+    locale,
+    messages
+  }
+}
+
+/**
+ * @param {object} _schema
+ * @param {PartialCompileOptions} [partialOptions]
+ * @returns {CompiledLayout}
+ */
+export function compile (_schema, partialOptions = {}) {
+  const options = fillOptions(partialOptions)
+
+  const schema = /** @type {import('ajv').SchemaObject} */(clone(_schema))
+
+  schema.$id = schema.$id ?? '_jl'
+  resolveRefs(schema, options.ajv, options.locale)
+
+  /** @type {string[]} */
+  const validatePointers = []
+  /** @type {Record<string, import('@json-layout/vocabulary').NormalizedLayout>} */
+  const normalizedLayouts = {}
+  /** @type {import('@json-layout/vocabulary').Expression[]} */
+  const expressionsDefinitions = []
+
+  const skeletonTree = makeSkeletonTree(schema, options, validatePointers, normalizedLayouts, expressionsDefinitions, `${schema.$id}#`, 'main')
+
+  options.ajv.addSchema(schema)
+
+  const uriResolver = options.ajv.opts.uriResolver
+  /** @type {Record<string, import('ajv').ValidateFunction>} */
+  const validates = {}
+  for (const pointer of validatePointers) {
+    const fullPointer = uriResolver.resolve(schema.$id, pointer)
+    validates[pointer] = options.ajv.compile({ $ref: fullPointer })
+  }
+
+  /** @type {CompiledExpression[]} */
+  const expressions = []
+
+  for (const expression of expressionsDefinitions) {
+    /* if (expression.type === 'expr-eval') {
+      expressions.push(exprEvalParser.parse(expression.expr).toJSFunction(expressionsParams.join(',')))
+    } */
+    if (expression.type === 'js-fn') {
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
+      expressions.push(/** @type {CompiledExpression} */(new Function(...expressionsParams, expression.expr)))
+    }
+    if (expression.type === 'js-eval') {
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func, @typescript-eslint/restrict-plus-operands
+      expressions.push(/** @type {CompiledExpression} */(new Function(...expressionsParams, 'return (' + expression.expr + ')')))
+    }
+    if (expression.type === 'js-tpl') {
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func, @typescript-eslint/restrict-plus-operands
+      expressions.push(/** @type {CompiledExpression} */(new Function(...expressionsParams, 'return `' + expression.expr + '`')))
+    }
+  }
+
+  return {
+    options,
+    schema,
+    skeletonTree,
+    validates,
+    normalizedLayouts,
+    expressions,
+    locale: options.locale,
+    messages: options.messages,
+    // @ts-ignore
+    localizeErrors: ajvLocalize[options.locale] || ajvLocalize.en
+  }
+}

package/src/compile/serialize.js

@@ -0,0 +1,76 @@
+// import Debug from 'debug'
+import { ok } from 'assert/strict'
+import standaloneCode from 'ajv/dist/standalone/index.js'
+import { parseModule, generateCode, builders } from 'magicast'
+import { parse, print } from 'recast'
+
+/**
+ * @param {import('./index.js').CompiledLayout} compiledLayout
+ * @returns {string}
+ */
+export function serialize (compiledLayout) {
+  ok(compiledLayout.schema)
+  ok(compiledLayout.options)
+  const ajv = compiledLayout.options.ajv
+
+  /** @type {Record<string, string>} */
+  const validatesExports = {}
+  let i = 0
+  for (const pointer of Object.keys(compiledLayout.validates)) {
+    const fullPointer = ajv.opts.uriResolver.resolve(/** @type {string} */(compiledLayout.schema.$id), pointer)
+    const exportKey = `export${i++}`
+    ajv.addSchema({ $id: exportKey, $ref: fullPointer })
+    validatesExports[exportKey] = exportKey
+  }
+  let code = standaloneCode.default(ajv, validatesExports)
+
+  code = code.replace('"use strict";', '')
+
+  // some internal imports to ajv are not translated to asm, we do it here
+  // cf https://github.com/ajv-validator/ajv-formats/pull/73
+  if (code.includes('require("ajv-formats/dist/formats")')) {
+    code = 'import { fullFormats } from "ajv-formats/dist/formats.js";\n' + code
+    code = code.replace(/require\("ajv-formats\/dist\/formats"\)\.fullFormats/g, 'fullFormats')
+  }
+  if (code.includes('require("ajv/dist/runtime/ucs2length")')) {
+    code = 'import ucs2length from "ajv/dist/runtime/ucs2length.js";\n' + code
+    code = code.replace(/require\("ajv\/dist\/runtime\/ucs2length"\)/g, 'ucs2length')
+  }
+
+  // importe only the current locale from ajv-i18n
+  code = `import localizeErrors from "ajv-i18n/localize/${compiledLayout.locale}/index.js";
+export const exportLocalizeErrors = localizeErrors;\n` + code
+
+  i = 0
+  const expressionsNodes = []
+  for (const expression of compiledLayout.expressions) {
+    const fn = parse(expression.toString()).program.body[0]
+    fn.id = `expression${i++}`
+    code += `\n${print(fn)}\n`
+    expressionsNodes.push(builders.raw(fn.id))
+  }
+
+  const ast = parseModule(code)
+  ast.exports.compiledLayout = {
+    skeletonTree: compiledLayout.skeletonTree,
+    normalizedLayouts: compiledLayout.normalizedLayouts,
+    validates: {},
+    expressions: expressionsNodes,
+    locale: compiledLayout.locale,
+    messages: compiledLayout.messages,
+    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]
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete ast.exports[exportKey]
+  }
+
+  const generatedCode = generateCode(ast).code.replace('export const compiledLayout = {', 'const compiledLayout = {')
+
+  return generatedCode
+}

package/src/compile/skeleton-node.js

@@ -0,0 +1,162 @@
+// import Debug from 'debug'
+import { normalizeLayoutFragment, isSwitchStruct, isGetItemsExpression, isSelectLayout, isGetItemsFetch } from '@json-layout/vocabulary'
+import { makeSkeletonTree } from './skeleton-tree.js'
+
+/**
+ * @param {import('@json-layout/vocabulary').Expression[]} expressions
+ * @param {import('@json-layout/vocabulary').Expression} expression
+ */
+const pushExpression = (expressions, expression) => {
+  const index = expressions.findIndex(e => e.type === expression.type && e.expr === expression.expr)
+  if (index !== -1) {
+    expression.ref = index
+  } else {
+    expression.ref = expressions.length
+    expressions.push(expression)
+  }
+}
+
+/**
+ * @param {any} schema
+ * @param {import('./index.js').CompileOptions} options
+ * @param {string[]} validates
+ * @param {Record<string, import('@json-layout/vocabulary').NormalizedLayout>} normalizedLayouts
+ * @param {import('@json-layout/vocabulary').Expression[]} expressions
+ * @param {string | number} key
+ * @param {string} pointer
+ * @param {string | null} parentPointer
+ * @param {boolean} required
+ * @returns {import('./types.js').SkeletonNode}
+ */
+export function makeSkeletonNode (
+  schema,
+  options,
+  validates,
+  normalizedLayouts,
+  expressions,
+  key,
+  pointer,
+  parentPointer,
+  required
+) {
+  // consolidate schema
+  if (!schema.type && schema.properties) schema.type = 'object'
+
+  // improve on ajv error messages based on ajv-errors (https://ajv.js.org/packages/ajv-errors.html)
+  schema.errorMessage = schema.errorMessage ?? {}
+  /** @type {import('@json-layout/vocabulary').NormalizedLayout} */
+  const normalizedLayout = normalizedLayouts[pointer] ?? normalizeLayoutFragment(/** @type {import('@json-layout/vocabulary').SchemaFragment} */(schema), pointer, options.markdown)
+  normalizedLayouts[pointer] = normalizedLayout
+
+  const compObjects = isSwitchStruct(normalizedLayout) ? normalizedLayout.switch : [normalizedLayout]
+  for (const compObject of compObjects) {
+    if (schema.description && !compObject.help) compObject.help = schema.description
+    if (compObject.if) pushExpression(expressions, compObject.if)
+    if (isSelectLayout(compObject) && compObject.getItems) {
+      if (isGetItemsExpression(compObject.getItems)) pushExpression(expressions, compObject.getItems)
+      if (isGetItemsFetch(compObject.getItems)) pushExpression(expressions, compObject.getItems.url)
+      if (compObject.getItems.itemTitle) pushExpression(expressions, compObject.getItems.itemTitle)
+      if (compObject.getItems.itemKey) pushExpression(expressions, compObject.getItems.itemKey)
+      if (compObject.getItems.itemValue) pushExpression(expressions, compObject.getItems.itemValue)
+      if (compObject.getItems.itemsResults) pushExpression(expressions, compObject.getItems.itemsResults)
+    }
+  }
+
+  let defaultData
+  if (schema.const) defaultData = schema.const
+  else if (schema.default) defaultData = schema.default
+  if (required) {
+    if (schema.type === 'object') defaultData = {} // TODO: this is only true if property is required ?
+    if (schema.type === 'array') defaultData = []
+    if (schema.type === 'string' && !schema.format) defaultData = ''
+  }
+
+  /** @type {import('./types.js').SkeletonNode} */
+  const node = { key: key ?? '', pointer, parentPointer, defaultData }
+  if (schema.const) node.const = schema.const
+  if (schema.type === 'object') {
+    if (schema.properties) {
+      node.children = node.children ?? []
+      for (const propertyKey of Object.keys(schema.properties)) {
+        node.children.push(makeSkeletonNode(
+          schema.properties[propertyKey],
+          options,
+          validates,
+          normalizedLayouts,
+          expressions,
+          propertyKey,
+          `${pointer}/properties/${propertyKey}`,
+          pointer,
+          schema.required?.includes(propertyKey)
+        ))
+        if (schema?.required?.includes(propertyKey)) {
+          schema.errorMessage.required = schema.errorMessage.required ?? {}
+          schema.errorMessage.required[propertyKey] = options.messages.errorRequired
+        }
+      }
+    }
+    if (schema.allOf) {
+      node.children = node.children ?? []
+      for (let i = 0; i < schema.allOf.length; i++) {
+        node.children.push(makeSkeletonNode(
+          schema.allOf[i],
+          options,
+          validates,
+          normalizedLayouts,
+          expressions,
+          `$allOf-${i}`,
+          `${pointer}/allOf/${i}`,
+          pointer,
+          false
+        ))
+      }
+    }
+    if (schema.oneOf) {
+      const oneOfPointer = `${pointer}/oneOf`
+      normalizedLayouts[oneOfPointer] = normalizedLayouts[oneOfPointer] ?? normalizeLayoutFragment(schema, oneOfPointer, options.markdown, 'oneOf')
+      /** @type {import('./types.js').SkeletonTree[]} */
+      const childrenTrees = []
+      for (let i = 0; i < schema.oneOf.length; i++) {
+        if (!schema.oneOf[i].type) schema.oneOf[i].type = schema.type
+        const title = schema.oneOf[i].title ?? `option ${i}`
+        delete schema.oneOf[i].title
+        childrenTrees.push(makeSkeletonTree(schema.oneOf[i], options, validates, normalizedLayouts, expressions, `${oneOfPointer}/${i}`, title))
+      }
+      node.children = node.children ?? []
+      node.children.push({ key: '$oneOf', pointer: `${pointer}/oneOf`, parentPointer: pointer, childrenTrees })
+
+      schema.errorMessage.oneOf = options.messages.errorOneOf
+    }
+  }
+
+  if (schema.type === 'array' && schema.items) {
+    if (Array.isArray(schema.items)) {
+      node.children = schema.items.map((/** @type {any} */ itemSchema, /** @type {number} */ i) => {
+        return makeSkeletonNode(
+          itemSchema,
+          options,
+          validates,
+          normalizedLayouts,
+          expressions,
+          i,
+          `${pointer}/items/${i}`,
+          pointer,
+          true
+        )
+      })
+    } else {
+      node.childrenTrees = [
+        makeSkeletonTree(
+          schema.items,
+          options,
+          validates,
+          normalizedLayouts,
+          expressions,
+          `${pointer}/items`,
+          schema.items.title
+        )
+      ]
+    }
+  }
+  return node
+}

package/src/compile/skeleton-tree.js

@@ -0,0 +1,28 @@
+// import Debug from 'debug'
+import { makeSkeletonNode } from './skeleton-node.js'
+
+// const debug = Debug('json-layout:compile-raw')
+
+/**
+ * @param {any} schema
+ * @param {import('./index.js').CompileOptions} options
+ * @param {string[]} validates
+ * @param {Record<string, import('@json-layout/vocabulary').NormalizedLayout>} normalizedLayouts
+ * @param {import('@json-layout/vocabulary').Expression[]} expressions
+ * @param {string} pointer
+ * @param {string} title
+ * @returns {import('./types.js').SkeletonTree}
+ */
+export function makeSkeletonTree (
+  schema,
+  options,
+  validates,
+  normalizedLayouts,
+  expressions,
+  pointer,
+  title
+) {
+  const root = makeSkeletonNode(schema, options, validates, normalizedLayouts, expressions, '', pointer, null, true)
+  validates.push(pointer)
+  return { title, root }
+}

package/src/compile/types.ts

@@ -0,0 +1,50 @@
+import type ajvModule from 'ajv'
+import type MarkdownIt from 'markdown-it'
+import { type NormalizedLayout, type StateNodeOptions } from '@json-layout/vocabulary'
+import { type ValidateFunction, type SchemaObject } from 'ajv'
+import { type Display } from '../state/utils/display.js'
+import { type LocaleMessages } from '../i18n/types.js'
+
+export type CompiledExpression = (data: any, options: StateNodeOptions, display: Display) => any
+
+export interface CompileOptions {
+  ajv: ajvModule.default
+  code: boolean
+  markdown: (text: string) => string
+  markdownIt?: MarkdownIt.Options
+  locale: string
+  messages: LocaleMessages
+}
+
+export type PartialCompileOptions = Partial<Omit<CompileOptions, 'messages'>> & { messages?: Partial<LocaleMessages> }
+
+export interface CompiledLayout {
+  options?: CompileOptions
+  schema?: SchemaObject
+  skeletonTree: SkeletonTree
+  validates: Record<string, ValidateFunction>
+  normalizedLayouts: Record<string, NormalizedLayout>
+  expressions: CompiledExpression[]
+  locale: string
+  messages: LocaleMessages
+  localizeErrors: (errors: ajvModule.ErrorObject[]) => void
+}
+
+// a tree is a root node and a validation function
+// it will be used to instantiate a StateLayoutTree with 1 validation context
+export interface SkeletonTree {
+  title: string
+  root: SkeletonNode
+}
+
+// a skeleton node is a light recursive structure
+// at runtime each one will be instantiated as a StateNode with a value and an associated component instance
+export interface SkeletonNode {
+  key: string | number
+  pointer: string
+  parentPointer: string | null
+  defaultData?: unknown
+  const?: unknown
+  children?: SkeletonNode[] // optional children in the case of arrays and object nodes
+  childrenTrees?: SkeletonTree[] // other trees that can be instantiated with separate validation (for example in the case of new array items of oneOfs, etc)
+}

package/src/compile/utils/resolve-refs.js

@@ -0,0 +1,69 @@
+import ajvModule from 'ajv'
+
+const Ajv = ajvModule.default
+
+/**
+ * @param {Record<string, import('ajv').SchemaObject>} schemas
+ * @param {string} ref
+ * @param {ajvModule.default} ajv
+ * @returns {[any, string]}
+ */
+const getJSONRef = (schemas, ref, ajv) => {
+  const [schemaId, pointer] = ref.split('#')
+  schemas[schemaId] = schemas[schemaId] ?? (ajv.getSchema(schemaId)?.schema)
+  if (!schemas[schemaId]) throw new Error(`reference not found ${schemaId}`)
+  const pointerParts = pointer.split('/').filter(p => !!p)
+  const { value: fragment } = pointerParts.reduce((a, pointerPart) => {
+    a.path.push(pointerPart)
+    if (!(pointerPart in a.value)) throw new Error(`reference not found ${schemaId}#${a.path.join('/')}`)
+    a.value = a.value[pointerPart]
+    return a
+  }, { path: ['/'], value: schemas[schemaId] })
+  return [fragment, schemaId]
+}
+
+/**
+ * @param {Record<string, import('ajv').SchemaObject>} schemas
+ * @param {import('ajv').SchemaObject} schemaFragment
+ * @param {string} schemaId
+ * @param {ajvModule.default} ajv
+ * @param {string} locale
+ * @returns {import('ajv').SchemaObject}
+ */
+const recurse = (schemas, schemaFragment, schemaId, ajv, locale = 'en') => {
+  for (const key of Object.keys(schemaFragment)) {
+    if (schemaFragment[key] && typeof schemaFragment[key] === 'object') {
+      if ('$ref' in schemaFragment[key]) {
+        const fullRef = ajv.opts.uriResolver.resolve(schemaId, schemaFragment[key].$ref).replace('~$locale~', locale)
+        const fullRefDefaultLocale = ajv.opts.uriResolver.resolve(schemaId, schemaFragment[key].$ref).replace('~$locale~', 'en')
+        let refFragment, refSchemaId
+        try {
+          [refFragment, refSchemaId] = getJSONRef(schemas, fullRef, ajv)
+        } catch (err) {
+          [refFragment, refSchemaId] = getJSONRef(schemas, fullRefDefaultLocale, ajv)
+        }
+        if (typeof refFragment === 'object' && !Array.isArray(refFragment)) {
+          schemaFragment[key] = { ...refFragment, ...schemaFragment[key] }
+          delete schemaFragment[key].$ref
+        } else {
+          schemaFragment[key] = refFragment
+        }
+        recurse(schemas, schemaFragment[key], refSchemaId, ajv, locale)
+      } else {
+        recurse(schemas, schemaFragment[key], schemaId, ajv, locale)
+      }
+    }
+  }
+  return schemaFragment
+}
+
+/**
+ * @param {import('ajv').SchemaObject} schema
+ * @param {ajvModule.default} ajv
+ * @param {string} locale
+ * @returns {import('ajv').SchemaObject}
+ */
+export function resolveRefs (schema, ajv, locale = 'en') {
+  if (!schema.$id) throw new Error('missing schema id')
+  return recurse({ [schema.$id]: schema }, schema, schema.$id, ajv ?? new Ajv(), locale)
+}

package/src/i18n/en.js

@@ -0,0 +1,10 @@
+/** @type {import('./types.js').LocaleMessages} */
+export default {
+  errorOneOf: 'chose one',
+  errorRequired: 'required information',
+  addItem: 'Add item',
+  delete: 'Delete',
+  edit: 'Edit',
+  duplicate: 'Duplicate',
+  sort: 'Sort'
+}

package/src/i18n/fr.js

@@ -0,0 +1,10 @@
+/** @type {import('./types.js').LocaleMessages} */
+export default {
+  errorOneOf: 'choisissez une valeur',
+  errorRequired: 'information obligatoire',
+  addItem: 'Ajouter un élément',
+  delete: 'Supprimer',
+  edit: 'Éditer',
+  duplicate: 'Dupliquer',
+  sort: 'Trier'
+}

package/src/i18n/index.js

@@ -0,0 +1,8 @@
+import en from './en.js'
+import fr from './fr.js'
+
+/** @type {Record<string, import('./types.js').LocaleMessages>} */
+export default {
+  en,
+  fr
+}

package/src/i18n/types.ts

@@ -0,0 +1,14 @@
+export interface CompileOptionsMessages {
+  errorOneOf: string
+  errorRequired: string
+}
+
+export interface StateOptionsMessages {
+  addItem: string
+  delete: string
+  edit: string
+  duplicate: string
+  sort: string
+}
+
+export type LocaleMessages = CompileOptionsMessages & StateOptionsMessages

package/src/index.js

@@ -0,0 +1,3 @@
+export * from './compile/index.js'
+export * from './state/index.js'
+export { default as i18n } from './i18n/index.js'