@jsonforms/core 3.3.0-beta.0 → 3.3.0

package/lib/util/resolvers.d.ts

@@ -1,25 +1,25 @@
-import type { JsonSchema } from '../models';
-/**
- * Map for storing refs and the respective schemas they are pointing to.
- */
-export interface ReferenceSchemaMap {
-    [ref: string]: JsonSchema;
-}
-export declare const resolveData: (instance: any, dataPath: string) => any;
-/**
- * Finds all references inside the given schema.
- *
- * @param schema The {@link JsonSchema} to find the references in
- * @param result The initial result map, default: empty map (this parameter is used for recursion
- *               inside the function)
- * @param resolveTuples Whether arrays of tuples should be considered; default: false
- */
-export declare const findAllRefs: (schema: JsonSchema, result?: ReferenceSchemaMap, resolveTuples?: boolean) => ReferenceSchemaMap;
-/**
- * Resolve the given schema path in order to obtain a subschema.
- * @param {JsonSchema} schema the root schema from which to start
- * @param {string} schemaPath the schema path to be resolved
- * @param {JsonSchema} rootSchema the actual root schema
- * @returns {JsonSchema} the resolved sub-schema
- */
-export declare const resolveSchema: (schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema) => JsonSchema;
+import type { JsonSchema } from '../models';
+/**
+ * Map for storing refs and the respective schemas they are pointing to.
+ */
+export interface ReferenceSchemaMap {
+    [ref: string]: JsonSchema;
+}
+export declare const resolveData: (instance: any, dataPath: string) => any;
+/**
+ * Finds all references inside the given schema.
+ *
+ * @param schema The {@link JsonSchema} to find the references in
+ * @param result The initial result map, default: empty map (this parameter is used for recursion
+ *               inside the function)
+ * @param resolveTuples Whether arrays of tuples should be considered; default: false
+ */
+export declare const findAllRefs: (schema: JsonSchema, result?: ReferenceSchemaMap, resolveTuples?: boolean) => ReferenceSchemaMap;
+/**
+ * Resolve the given schema path in order to obtain a subschema.
+ * @param {JsonSchema} schema the root schema from which to start
+ * @param {string} schemaPath the schema path to be resolved
+ * @param {JsonSchema} rootSchema the actual root schema
+ * @returns {JsonSchema} the resolved sub-schema
+ */
+export declare const resolveSchema: (schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema) => JsonSchema;

package/lib/util/runtime.d.ts

@@ -1,17 +1,17 @@
-import { JsonSchema, UISchemaElement } from '../models';
-import type Ajv from 'ajv';
-import type { JsonFormsState } from '../store';
-export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const hasShowRule: (uischema: UISchemaElement) => boolean;
-export declare const hasEnableRule: (uischema: UISchemaElement) => boolean;
-export declare const isVisible: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-export declare const isEnabled: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
-/**
- * Indicates whether the given `uischema` element shall be enabled or disabled.
- * Checks the global readonly flag, uischema rule, uischema options (including the config),
- * the schema and the enablement indicator of the parent.
- */
-export declare const isInherentlyEnabled: (state: JsonFormsState, ownProps: any, uischema: UISchemaElement, schema: (JsonSchema & {
-    readOnly?: boolean;
-}) | undefined, rootData: any, config: any) => any;
+import { JsonSchema, UISchemaElement } from '../models';
+import type Ajv from 'ajv';
+import type { JsonFormsState } from '../store';
+export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const hasShowRule: (uischema: UISchemaElement) => boolean;
+export declare const hasEnableRule: (uischema: UISchemaElement) => boolean;
+export declare const isVisible: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+export declare const isEnabled: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
+/**
+ * Indicates whether the given `uischema` element shall be enabled or disabled.
+ * Checks the global readonly flag, uischema rule, uischema options (including the config),
+ * the schema and the enablement indicator of the parent.
+ */
+export declare const isInherentlyEnabled: (state: JsonFormsState, ownProps: any, uischema: UISchemaElement, schema: (JsonSchema & {
+    readOnly?: boolean;
+}) | undefined, rootData: any, config: any) => any;

package/lib/util/schema.d.ts

@@ -1,10 +1,10 @@
-import { JsonSchema } from '../models';
-export declare const getFirstPrimitiveProp: (schema: any) => string;
-/**
- * Tests whether the schema has an enum based on oneOf.
- */
-export declare const isOneOfEnumSchema: (schema: JsonSchema) => boolean;
-/**
- * Tests whether the schema has an enum.
- */
-export declare const isEnumSchema: (schema: JsonSchema) => any;
+import { JsonSchema } from '../models';
+export declare const getFirstPrimitiveProp: (schema: any) => string;
+/**
+ * Tests whether the schema has an enum based on oneOf.
+ */
+export declare const isOneOfEnumSchema: (schema: JsonSchema) => boolean;
+/**
+ * Tests whether the schema has an enum.
+ */
+export declare const isEnumSchema: (schema: JsonSchema) => any;

package/lib/util/type.d.ts

@@ -1,174 +1,174 @@
-export interface Action<T = any> {
-    type: T;
-}
-/**
- * An Action type which accepts any other properties.
- * This is mainly for the use of the `Reducer` type.
- * This is not part of `Action` itself to prevent types that extend `Action` from
- * having an index signature.
- */
-export interface AnyAction extends Action {
-    [extraProps: string]: any;
-}
-/**
- * A *dispatching function* (or simply *dispatch function*) is a function that
- * accepts an action or an async action; it then may or may not dispatch one
- * or more actions to the store.
- *
- * We must distinguish between dispatching functions in general and the base
- * `dispatch` function provided by the store instance without any middleware.
- *
- * The base dispatch function *always* synchronously sends an action to the
- * store's reducer, along with the previous state returned by the store, to
- * calculate a new state. It expects actions to be plain objects ready to be
- * consumed by the reducer.
- *
- * Middleware wraps the base dispatch function. It allows the dispatch
- * function to handle async actions in addition to actions. Middleware may
- * transform, delay, ignore, or otherwise interpret actions or async actions
- * before passing them to the next middleware.
- *
- * @template A The type of things (actions or otherwise) which may be
- *   dispatched.
- */
-export type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
-/**
- * A store is an object that holds the application's state tree.
- * There should only be a single store in a Redux app, as the composition
- * happens on the reducer level.
- *
- * @template S The type of state held by this store.
- * @template A the type of actions which may be dispatched by this store.
- */
-export interface Store<S = any, A extends Action = AnyAction> {
-    /**
-     * Dispatches an action. It is the only way to trigger a state change.
-     *
-     * The `reducer` function, used to create the store, will be called with the
-     * current state tree and the given `action`. Its return value will be
-     * considered the **next** state of the tree, and the change listeners will
-     * be notified.
-     *
-     * The base implementation only supports plain object actions. If you want
-     * to dispatch a Promise, an Observable, a thunk, or something else, you
-     * need to wrap your store creating function into the corresponding
-     * middleware. For example, see the documentation for the `redux-thunk`
-     * package. Even the middleware will eventually dispatch plain object
-     * actions using this method.
-     *
-     * @param action A plain object representing “what changed”. It is a good
-     *   idea to keep actions serializable so you can record and replay user
-     *   sessions, or use the time travelling `redux-devtools`. An action must
-     *   have a `type` property which may not be `undefined`. It is a good idea
-     *   to use string constants for action types.
-     *
-     * @returns For convenience, the same action object you dispatched.
-     *
-     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
-     * return something else (for example, a Promise you can await).
-     */
-    dispatch: Dispatch<A>;
-    /**
-     * Reads the state tree managed by the store.
-     *
-     * @returns The current state tree of your application.
-     */
-    getState(): S;
-    /**
-     * Adds a change listener. It will be called any time an action is
-     * dispatched, and some part of the state tree may potentially have changed.
-     * You may then call `getState()` to read the current state tree inside the
-     * callback.
-     *
-     * You may call `dispatch()` from a change listener, with the following
-     * caveats:
-     *
-     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
-     * If you subscribe or unsubscribe while the listeners are being invoked,
-     * this will not have any effect on the `dispatch()` that is currently in
-     * progress. However, the next `dispatch()` call, whether nested or not,
-     * will use a more recent snapshot of the subscription list.
-     *
-     * 2. The listener should not expect to see all states changes, as the state
-     * might have been updated multiple times during a nested `dispatch()` before
-     * the listener is called. It is, however, guaranteed that all subscribers
-     * registered before the `dispatch()` started will be called with the latest
-     * state by the time it exits.
-     *
-     * @param listener A callback to be invoked on every dispatch.
-     * @returns A function to remove this change listener.
-     */
-    subscribe(listener: () => void): Unsubscribe;
-    /**
-     * Replaces the reducer currently used by the store to calculate the state.
-     *
-     * You might need this if your app implements code splitting and you want to
-     * load some of the reducers dynamically. You might also need this if you
-     * implement a hot reloading mechanism for Redux.
-     *
-     * @param nextReducer The reducer for the store to use instead.
-     */
-    replaceReducer(nextReducer: Reducer<S, A>): void;
-    /**
-     * Interoperability point for observable/reactive libraries.
-     * @returns {observable} A minimal observable of state changes.
-     * For more information, see the observable proposal:
-     * https://github.com/tc39/proposal-observable
-     */
-    [Symbol.observable](): Observable<S>;
-}
-/**
- * A minimal observable of state changes.
- * For more information, see the observable proposal:
- * https://github.com/tc39/proposal-observable
- */
-export type Observable<T> = {
-    /**
-     * The minimal observable subscription method.
-     * @param {Object} observer Any object that can be used as an observer.
-     * The observer object should have a `next` method.
-     * @returns {subscription} An object with an `unsubscribe` method that can
-     * be used to unsubscribe the observable from the store, and prevent further
-     * emission of values from the observable.
-     */
-    subscribe(observer: Observer<T>): {
-        unsubscribe: Unsubscribe;
-    };
-    [Symbol.observable](): Observable<T>;
-};
-/**
- * An Observer is used to receive data from an Observable, and is supplied as
- * an argument to subscribe.
- */
-export type Observer<T> = {
-    next?(value: T): void;
-};
-/**
- * A *reducer* (also called a *reducing function*) is a function that accepts
- * an accumulation and a value and returns a new accumulation. They are used
- * to reduce a collection of values down to a single value
- *
- * Reducers are not unique to Redux—they are a fundamental concept in
- * functional programming.  Even most non-functional languages, like
- * JavaScript, have a built-in API for reducing. In JavaScript, it's
- * `Array.prototype.reduce()`.
- *
- * In Redux, the accumulated value is the state object, and the values being
- * accumulated are actions. Reducers calculate a new state given the previous
- * state and an action. They must be *pure functions*—functions that return
- * the exact same output for given inputs. They should also be free of
- * side-effects. This is what enables exciting features like hot reloading and
- * time travel.
- *
- * Reducers are the most important concept in Redux.
- *
- * *Do not put API calls into reducers.*
- *
- * @template S The type of state consumed and produced by this reducer.
- * @template A The type of actions the reducer can potentially respond to.
- */
-export type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
-/**
- * Function to remove listener added by `Store.subscribe()`.
- */
-export type Unsubscribe = () => void;
+export interface Action<T = any> {
+    type: T;
+}
+/**
+ * An Action type which accepts any other properties.
+ * This is mainly for the use of the `Reducer` type.
+ * This is not part of `Action` itself to prevent types that extend `Action` from
+ * having an index signature.
+ */
+export interface AnyAction extends Action {
+    [extraProps: string]: any;
+}
+/**
+ * A *dispatching function* (or simply *dispatch function*) is a function that
+ * accepts an action or an async action; it then may or may not dispatch one
+ * or more actions to the store.
+ *
+ * We must distinguish between dispatching functions in general and the base
+ * `dispatch` function provided by the store instance without any middleware.
+ *
+ * The base dispatch function *always* synchronously sends an action to the
+ * store's reducer, along with the previous state returned by the store, to
+ * calculate a new state. It expects actions to be plain objects ready to be
+ * consumed by the reducer.
+ *
+ * Middleware wraps the base dispatch function. It allows the dispatch
+ * function to handle async actions in addition to actions. Middleware may
+ * transform, delay, ignore, or otherwise interpret actions or async actions
+ * before passing them to the next middleware.
+ *
+ * @template A The type of things (actions or otherwise) which may be
+ *   dispatched.
+ */
+export type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
+/**
+ * A store is an object that holds the application's state tree.
+ * There should only be a single store in a Redux app, as the composition
+ * happens on the reducer level.
+ *
+ * @template S The type of state held by this store.
+ * @template A the type of actions which may be dispatched by this store.
+ */
+export interface Store<S = any, A extends Action = AnyAction> {
+    /**
+     * Dispatches an action. It is the only way to trigger a state change.
+     *
+     * The `reducer` function, used to create the store, will be called with the
+     * current state tree and the given `action`. Its return value will be
+     * considered the **next** state of the tree, and the change listeners will
+     * be notified.
+     *
+     * The base implementation only supports plain object actions. If you want
+     * to dispatch a Promise, an Observable, a thunk, or something else, you
+     * need to wrap your store creating function into the corresponding
+     * middleware. For example, see the documentation for the `redux-thunk`
+     * package. Even the middleware will eventually dispatch plain object
+     * actions using this method.
+     *
+     * @param action A plain object representing “what changed”. It is a good
+     *   idea to keep actions serializable so you can record and replay user
+     *   sessions, or use the time travelling `redux-devtools`. An action must
+     *   have a `type` property which may not be `undefined`. It is a good idea
+     *   to use string constants for action types.
+     *
+     * @returns For convenience, the same action object you dispatched.
+     *
+     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+     * return something else (for example, a Promise you can await).
+     */
+    dispatch: Dispatch<A>;
+    /**
+     * Reads the state tree managed by the store.
+     *
+     * @returns The current state tree of your application.
+     */
+    getState(): S;
+    /**
+     * Adds a change listener. It will be called any time an action is
+     * dispatched, and some part of the state tree may potentially have changed.
+     * You may then call `getState()` to read the current state tree inside the
+     * callback.
+     *
+     * You may call `dispatch()` from a change listener, with the following
+     * caveats:
+     *
+     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+     * If you subscribe or unsubscribe while the listeners are being invoked,
+     * this will not have any effect on the `dispatch()` that is currently in
+     * progress. However, the next `dispatch()` call, whether nested or not,
+     * will use a more recent snapshot of the subscription list.
+     *
+     * 2. The listener should not expect to see all states changes, as the state
+     * might have been updated multiple times during a nested `dispatch()` before
+     * the listener is called. It is, however, guaranteed that all subscribers
+     * registered before the `dispatch()` started will be called with the latest
+     * state by the time it exits.
+     *
+     * @param listener A callback to be invoked on every dispatch.
+     * @returns A function to remove this change listener.
+     */
+    subscribe(listener: () => void): Unsubscribe;
+    /**
+     * Replaces the reducer currently used by the store to calculate the state.
+     *
+     * You might need this if your app implements code splitting and you want to
+     * load some of the reducers dynamically. You might also need this if you
+     * implement a hot reloading mechanism for Redux.
+     *
+     * @param nextReducer The reducer for the store to use instead.
+     */
+    replaceReducer(nextReducer: Reducer<S, A>): void;
+    /**
+     * Interoperability point for observable/reactive libraries.
+     * @returns {observable} A minimal observable of state changes.
+     * For more information, see the observable proposal:
+     * https://github.com/tc39/proposal-observable
+     */
+    [Symbol.observable](): Observable<S>;
+}
+/**
+ * A minimal observable of state changes.
+ * For more information, see the observable proposal:
+ * https://github.com/tc39/proposal-observable
+ */
+export type Observable<T> = {
+    /**
+     * The minimal observable subscription method.
+     * @param {Object} observer Any object that can be used as an observer.
+     * The observer object should have a `next` method.
+     * @returns {subscription} An object with an `unsubscribe` method that can
+     * be used to unsubscribe the observable from the store, and prevent further
+     * emission of values from the observable.
+     */
+    subscribe(observer: Observer<T>): {
+        unsubscribe: Unsubscribe;
+    };
+    [Symbol.observable](): Observable<T>;
+};
+/**
+ * An Observer is used to receive data from an Observable, and is supplied as
+ * an argument to subscribe.
+ */
+export type Observer<T> = {
+    next?(value: T): void;
+};
+/**
+ * A *reducer* (also called a *reducing function*) is a function that accepts
+ * an accumulation and a value and returns a new accumulation. They are used
+ * to reduce a collection of values down to a single value
+ *
+ * Reducers are not unique to Redux—they are a fundamental concept in
+ * functional programming.  Even most non-functional languages, like
+ * JavaScript, have a built-in API for reducing. In JavaScript, it's
+ * `Array.prototype.reduce()`.
+ *
+ * In Redux, the accumulated value is the state object, and the values being
+ * accumulated are actions. Reducers calculate a new state given the previous
+ * state and an action. They must be *pure functions*—functions that return
+ * the exact same output for given inputs. They should also be free of
+ * side-effects. This is what enables exciting features like hot reloading and
+ * time travel.
+ *
+ * Reducers are the most important concept in Redux.
+ *
+ * *Do not put API calls into reducers.*
+ *
+ * @template S The type of state consumed and produced by this reducer.
+ * @template A The type of actions the reducer can potentially respond to.
+ */
+export type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
+/**
+ * Function to remove listener added by `Store.subscribe()`.
+ */
+export type Unsubscribe = () => void;

package/lib/util/uischema.d.ts

@@ -1,18 +1,18 @@
-import { UISchemaElement } from '../models';
-export type IterateCallback = (uischema: UISchemaElement) => void;
-export declare const setReadonly: (uischema: UISchemaElement) => void;
-export declare const unsetReadonly: (uischema: UISchemaElement) => void;
-export declare const iterateSchema: (uischema: UISchemaElement, toApply: IterateCallback) => void;
-/**
- * Transform a dotted path to a uiSchema properties path
- * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
- * @return the uiSchema properties path (i.e. /properties/articles/properties/comment/properties/author)
- */
-export declare const getPropPath: (path: string) => string;
-/**
- * Find a control in a uiSchema, based on the dotted path of the schema value
- * @param {UISchemaElement} uiSchema the uiSchema to search from
- * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
- * @return {UISchemaElement} or undefined if not found
- */
-export declare const findUiControl: (uiSchema: UISchemaElement, path: string) => UISchemaElement | undefined;
+import { UISchemaElement } from '../models';
+export type IterateCallback = (uischema: UISchemaElement) => void;
+export declare const setReadonly: (uischema: UISchemaElement) => void;
+export declare const unsetReadonly: (uischema: UISchemaElement) => void;
+export declare const iterateSchema: (uischema: UISchemaElement, toApply: IterateCallback) => void;
+/**
+ * Transform a dotted path to a uiSchema properties path
+ * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
+ * @return the uiSchema properties path (i.e. /properties/articles/properties/comment/properties/author)
+ */
+export declare const getPropPath: (path: string) => string;
+/**
+ * Find a control in a uiSchema, based on the dotted path of the schema value
+ * @param {UISchemaElement} uiSchema the uiSchema to search from
+ * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
+ * @return {UISchemaElement} or undefined if not found
+ */
+export declare const findUiControl: (uiSchema: UISchemaElement, path: string) => UISchemaElement | undefined;

package/lib/util/util.d.ts

@@ -1,57 +1,57 @@
-import type { JsonSchema, Scoped, UISchemaElement } from '..';
-import type Ajv from 'ajv';
-/**
- * Returns the string representation of the given date. The format of the output string can be specified:
- * - 'date' for a date-only string (YYYY-MM-DD),
- * - 'time' for a time-only string (HH:mm:ss), or
- * - 'date-time' for a full date-time string in ISO format (YYYY-MM-DDTHH:mm:ss.sssZ).
- * If no format is specified, the full date-time ISO string is returned by default.
- *
- * @returns {string} A string representation of the date in the specified format.
- *
- * @example
- * // returns '2023-11-09'
- * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date');
- *
- * @example
- * // returns '14:22:54'
- * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'time');
- *
- * @example
- * // returns '2023-11-09T14:22:54.131Z'
- * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date-time');
- *
- * @example
- * // returns '2023-11-09T14:22:54.131Z'
- * convertDateToString(new Date('2023-11-09T14:22:54.131Z'));
- */
-export declare const convertDateToString: (date: Date, format?: 'date' | 'time' | 'date-time') => string;
-/**
- * Escape the given string such that it can be used as a class name,
- * i.e. hashes and slashes will be replaced.
- *
- * @param {string} s the string that should be converted to a valid class name
- * @returns {string} the escaped string
- */
-export declare const convertToValidClassName: (s: string) => string;
-export declare const formatErrorMessage: (errors: string[]) => string;
-export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
-/**
- * Derives the type of the jsonSchema element
- */
-export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
-/**
- * Convenience wrapper around resolveData and resolveSchema.
- */
-export declare const Resolve: {
-    schema(schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema): JsonSchema;
-    data(data: any, path: string): any;
-};
-export declare const Paths: {
-    compose: (path1: string, path2: string) => string;
-    fromScoped: (scopable: Scoped) => string;
-};
-export declare const Runtime: {
-    isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
-    isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
-};
+import type { JsonSchema, Scoped, UISchemaElement } from '..';
+import type Ajv from 'ajv';
+/**
+ * Returns the string representation of the given date. The format of the output string can be specified:
+ * - 'date' for a date-only string (YYYY-MM-DD),
+ * - 'time' for a time-only string (HH:mm:ss), or
+ * - 'date-time' for a full date-time string in ISO format (YYYY-MM-DDTHH:mm:ss.sssZ).
+ * If no format is specified, the full date-time ISO string is returned by default.
+ *
+ * @returns {string} A string representation of the date in the specified format.
+ *
+ * @example
+ * // returns '2023-11-09'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date');
+ *
+ * @example
+ * // returns '14:22:54'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'time');
+ *
+ * @example
+ * // returns '2023-11-09T14:22:54.131Z'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'), 'date-time');
+ *
+ * @example
+ * // returns '2023-11-09T14:22:54.131Z'
+ * convertDateToString(new Date('2023-11-09T14:22:54.131Z'));
+ */
+export declare const convertDateToString: (date: Date, format?: 'date' | 'time' | 'date-time') => string;
+/**
+ * Escape the given string such that it can be used as a class name,
+ * i.e. hashes and slashes will be replaced.
+ *
+ * @param {string} s the string that should be converted to a valid class name
+ * @returns {string} the escaped string
+ */
+export declare const convertToValidClassName: (s: string) => string;
+export declare const formatErrorMessage: (errors: string[]) => string;
+export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
+/**
+ * Derives the type of the jsonSchema element
+ */
+export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
+/**
+ * Convenience wrapper around resolveData and resolveSchema.
+ */
+export declare const Resolve: {
+    schema(schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema): JsonSchema;
+    data(data: any, path: string): any;
+};
+export declare const Paths: {
+    compose: (path1: string, path2: string) => string;
+    fromScoped: (scopable: Scoped) => string;
+};
+export declare const Runtime: {
+    isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
+    isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;
+};

package/lib/util/validator.d.ts

@@ -1,3 +1,3 @@
-import Ajv from 'ajv';
-import type { Options } from 'ajv';
-export declare const createAjv: (options?: Options) => Ajv;
+import Ajv from 'ajv';
+import type { Options } from 'ajv';
+export declare const createAjv: (options?: Options) => Ajv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonforms/core",
-  "version": "3.3.0-beta.0",
+  "version": "3.3.0",
   "description": "Core module of JSON Forms",
   "repository": "https://github.com/eclipsesource/jsonforms",
   "bugs": "https://github.com/eclipsesource/jsonforms/issues",
@@ -86,7 +86,7 @@
     "ts-node": "^10.4.0",
     "tslib": "^2.5.0",
     "typedoc": "~0.25.3",
-    "typescript": "~4.9.5"
+    "typescript": "~5.2.2"
   },
   "scripts": {
     "build": "rollup -c rollup.config.js",