@limetech/lime-elements 37.7.1 → 37.8.1

package/dist/types/components/form/form.types.d.ts

@@ -181,8 +181,8 @@ export interface LimeSchemaOptions {
   help?: string | Partial<Help>;
 }
 /**
- * @public
  * Options for a layout to be used in a form
+ * @public
  */
 export type LimeLayoutOptions = GridLayoutOptions & RowLayoutOptions;
 /**
@@ -211,8 +211,8 @@ export interface FormLayoutOptions<T extends FormLayoutType | `${FormLayoutType}
   type: T;
 }
 /**
- * @public
  * Layout options for a grid layout
+ * @public
  */
 export interface GridLayoutOptions extends FormLayoutOptions<FormLayoutType | `${FormLayoutType}`> {
   /**
@@ -237,8 +237,8 @@ export interface GridLayoutOptions extends FormLayoutOptions<FormLayoutType | `$
   dense?: boolean;
 }
 /**
- * @public
  * Layout options for a row layout
+ * @public
  */
 export interface RowLayoutOptions extends FormLayoutOptions<FormLayoutType | `${FormLayoutType}`> {
   /**
@@ -248,8 +248,8 @@ export interface RowLayoutOptions extends FormLayoutOptions<FormLayoutType | `${
   icon?: string;
 }
 /**
- * @public
  * Represents the layout types for a form.
+ * @public
  */
 export declare enum FormLayoutType {
   /**
@@ -270,9 +270,340 @@ export declare enum FormLayoutType {
   Row = "row"
 }
 /**
- * @public
  * Represents the JSON schema with Lime specific options
+ * @public
  */
-export interface FormSchema extends JSONSchema7 {
+export interface FormSchema<T extends Record<string, any> = any> extends JSONSchema7 {
+  /**
+   * The value of "items" MUST be either a valid JSON Schema or an array
+   * of valid JSON Schemas.
+   *
+   * This keyword determines how child instances validate for arrays, and
+   * does not directly validate the immediate instance itself.
+   *
+   * If "items" is a schema, validation succeeds if all elements in the
+   * array successfully validate against that schema.
+   *
+   * If "items" is an array of schemas, validation succeeds if each
+   * element of the instance validates against the schema at the same
+   * position, if any.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4.1
+   */
+  items?: FormSchemaArrayItem<T> | Array<FormSchemaArrayItem<T>>;
+  /**
+   * The value of "items" MUST be either a valid JSON Schema or an array
+   * of valid JSON Schemas.
+   *
+   * This keyword determines how child instances validate for arrays, and
+   * does not directly validate the immediate instance itself.
+   *
+   * If "items" is a schema, validation succeeds if all elements in the
+   * array successfully validate against that schema.
+   *
+   * If "items" is an array of schemas, validation succeeds if each
+   * element of the instance validates against the schema at the same
+   * position, if any.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4.2
+   */
+  additionalItems?: FormSchemaArrayItem<T>;
+  /**
+   * The value of this keyword MUST be a valid JSON Schema.
+   *
+   * An array instance is valid against "contains" if at least one of its
+   * elements is valid against the given schema.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4.6
+   */
+  contains?: FormSchemaArrayItem<T>;
+  /**
+   * The value of this keyword MUST be an array.  Elements of this array,
+   * if any, MUST be strings, and MUST be unique.
+   *
+   * An object instance is valid against this keyword if every item in the
+   * array is the name of a property in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty array.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.3
+   */
+  required?: Array<ReplaceObjectType<T, Extract<keyof T, string>, string>>;
+  /**
+   * The value of "properties" MUST be an object.  Each value of this
+   * object MUST be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and
+   * does not directly validate the immediate instance itself.
+   *
+   * Validation succeeds if, for each name that appears in both the
+   * instance and as a name within this keyword's value, the child
+   * instance for that name successfully validates against the
+   * corresponding schema.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.4
+   */
+  properties?: ReplaceObjectType<T, FormSubKeySchema<T>, Record<string, FormSchema>>;
+  /**
+   * This keyword's value MUST be a non-empty array.  Each item of the
+   * array MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it
+   * validates successfully against all schemas defined by this keyword's
+   * value.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.7.1
+   */
+  allOf?: Array<FormSchemaArrayItem<T>>;
+  /**
+   * This keyword's value MUST be a non-empty array.  Each item of the
+   * array MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it
+   * validates successfully against at least one schema defined by this
+   * keyword's value.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.7.2
+   */
+  anyOf?: Array<FormSchemaArrayItem<T>>;
+  /**
+   * This keyword's value MUST be a non-empty array.  Each item of the
+   * array MUST be a valid JSON Schema.
+   *
+   * An instance validates successfully against this keyword if it
+   * validates successfully against exactly one schema defined by this
+   * keyword's value.
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.7.3
+   */
+  oneOf?: Array<FormSchemaArrayItem<T>>;
+  /**
+   * The value of "patternProperties" MUST be an object.  Each property
+   * name of this object SHOULD be a valid regular expression, according
+   * to the ECMA 262 regular expression dialect.  Each property value of
+   * this object MUST be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and
+   * does not directly validate the immediate instance itself.  Validation
+   * of the primitive instance type against this keyword always succeeds.
+   *
+   * Validation succeeds if, for each instance name that matches any
+   * regular expressions that appear as a property name in this keyword's
+   * value, the child instance for that name successfully validates
+   * against each schema that corresponds to a matching regular
+   * expression.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.5
+   */
+  patternProperties?: Record<string, FormSchema>;
+  /**
+   * The value of "additionalProperties" MUST be a valid JSON Schema.
+   *
+   * This keyword determines how child instances validate for objects, and
+   * does not directly validate the immediate instance itself.
+   *
+   * Validation with "additionalProperties" applies only to the child
+   * values of instance names that do not match any names in "properties",
+   * and do not match any regular expression in "patternProperties".
+   *
+   * For all such properties, validation succeeds if the child instance
+   * validates against the "additionalProperties" schema.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.6
+   */
+  additionalProperties?: FormSchema | boolean;
+  /**
+   * This keyword specifies rules that are evaluated if the instance is an
+   * object and contains a certain property.
+   *
+   * This keyword's value MUST be an object.  Each property specifies a
+   * dependency.  Each dependency value MUST be an array or a valid JSON
+   * Schema.
+   *
+   * If the dependency value is a subschema, and the dependency key is a
+   * property in the instance, the entire instance must validate against
+   * the dependency value.
+   *
+   * If the dependency value is an array, each element in the array, if
+   * any, MUST be a string, and MUST be unique.  If the dependency key is
+   * a property in the instance, each of the items in the dependency value
+   * must be a property that exists in the instance.
+   *
+   * Omitting this keyword has the same behavior as an empty object.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.7
+   */
+  dependencies?: Record<string, FormSchema | string[]>;
+  /**
+   * The value of "propertyNames" MUST be a valid JSON Schema.
+   *
+   * If the instance is an object, this keyword validates if every
+   * property name in the instance validates against the provided schema.
+   * Note the property name that the schema is testing will always be a
+   * string.
+   *
+   * Omitting this keyword has the same behavior as an empty schema.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5.8
+   */
+  propertyNames?: FormSchema;
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * This validation outcome of this keyword's subschema has no direct
+   * effect on the overall validation result.  Rather, it controls which
+   * of the "then" or "else" keywords are evaluated.
+   *
+   * Instances that successfully validate against this keyword's subschema
+   * MUST also be valid against the subschema value of the "then" keyword,
+   * if present.
+   *
+   * Instances that fail to validate against this keyword's subschema MUST
+   * also be valid against the subschema value of the "else" keyword, if
+   * present.
+   *
+   * If annotations (Section 3.3) are being collected, they are collected
+   * from this keyword's subschema in the usual way, including when the
+   * keyword is present without either "then" or "else".
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.6.1
+   */
+  if?: FormSchema;
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * This validation outcome of this keyword's subschema has no direct
+   * effect on the overall validation result.  Rather, it controls which
+   * of the "then" or "else" keywords are evaluated.
+   *
+   * Instances that successfully validate against this keyword's subschema
+   * MUST also be valid against the subschema value of the "then" keyword,
+   * if present.
+   *
+   * Instances that fail to validate against this keyword's subschema MUST
+   * also be valid against the subschema value of the "else" keyword, if
+   * present.
+   *
+   * If annotations (Section 3.3) are being collected, they are collected
+   * from this keyword's subschema in the usual way, including when the
+   * keyword is present without either "then" or "else".
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.6.2
+   */
+  then?: FormSchema;
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * When "if" is present, and the instance fails to validate against its
+   * subschema, then valiation succeeds against this keyword if the
+   * instance successfully validates against this keyword's subschema.
+   *
+   * This keyword has no effect when "if" is absent, or when the instance
+   * successfully validates against its subschema.  Implementations MUST
+   * NOT evaluate the instance against this keyword, for either validation
+   * or annotation collection purposes, in such cases.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.6.3
+   */
+  else?: FormSchema;
+  /**
+   * This keyword's value MUST be a valid JSON Schema.
+   *
+   * An instance is valid against this keyword if it fails to validate
+   * successfully against the schema defined by this keyword.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.7.4
+   */
+  not?: FormSchema;
+  /**
+   * The "$defs" keywords provides a standardized location for
+   * schema authors to inline re-usable JSON Schemas into a more general
+   * schema.  The keyword does not directly affect the validation result.
+   *
+   * This keyword's value MUST be an object.  Each member value of this
+   * object MUST be a valid JSON Schema.
+   *
+   * As an example, here is a schema describing an array of positive
+   * integers, where the positive integer constraint is a subschema in
+   * "definitions":
+   * ```
+   * {
+   *     "type": "array",
+   *     "items": { "$ref": "#/definitions/positiveInteger" },
+   *     "definitions": {
+   *         "positiveInteger": {
+   *             "type": "integer",
+   *             "exclusiveMinimum": 0
+   *         }
+   *     }
+   * }
+   * ```
+   *
+   * $defs is the newer keyword introduced in the JSON Schema Draft 2019-09, while definitions is from the older drafts.
+   *
+   * The main difference is that definitions is no longer an official keyword in the latest JSON Schema specification (Draft 2019-09 and later),
+   * but it is still widely supported for backward compatibility.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  $defs?: Record<string, FormSchema>;
+  /**
+   * The "definitions" keywords provides a standardized location for
+   * schema authors to inline re-usable JSON Schemas into a more general
+   * schema.  The keyword does not directly affect the validation result.
+   *
+   * This keyword's value MUST be an object.  Each member value of this
+   * object MUST be a valid JSON Schema.
+   *
+   * As an example, here is a schema describing an array of positive
+   * integers, where the positive integer constraint is a subschema in
+   * "definitions":
+   * ```
+   * {
+   *     "type": "array",
+   *     "items": { "$ref": "#/definitions/positiveInteger" },
+   *     "definitions": {
+   *         "positiveInteger": {
+   *             "type": "integer",
+   *             "exclusiveMinimum": 0
+   *         }
+   *     }
+   * }
+   * ```
+   *
+   * $defs is the newer keyword introduced in the JSON Schema Draft 2019-09, while definitions is from the older drafts.
+   *
+   * The main difference is that definitions is no longer an official keyword in the latest JSON Schema specification (Draft 2019-09 and later),
+   * but it is still widely supported for backward compatibility.
+   *
+   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  definitions?: Record<string, FormSchema>;
 }
+/**
+ * Utility type for replacing object types with a specified type
+ * @public
+ */
+export type ReplaceObjectType<T, AllowedType, ElseType> = T extends any[] ? ElseType : T extends Record<string, any> ? AllowedType : ElseType;
+/**
+ * Utility type for supporting nested sub items in arrays
+ * @public
+ */
+export type FormSchemaArrayItem<T> = T extends any[] ? FormSchema<T[Extract<keyof T, number>]> : FormSchema;
+/**
+ * Utility type for recursive properties in a schema
+ * @public
+ */
+export type FormSubKeySchema<TObj> = Partial<{
+  [Key in Extract<keyof TObj, any>]: FormSchema<TObj[Key]>;
+}>;
 //# sourceMappingURL=form.types.d.ts.map

package/dist/types/components/form/schema.d.ts

@@ -1,6 +1,7 @@
-export declare function isObjectType(schema?: any): boolean;
-export declare function isArrayType(schema: any): boolean;
-export declare function isStringType(schema: any): boolean;
-export declare function isNumberType(schema: any): boolean;
-export declare function isIntegerType(schema: any): boolean;
+import { FormSchema } from './form.types';
+export declare function isObjectType(schema?: FormSchema): boolean;
+export declare function isArrayType(schema: FormSchema): boolean;
+export declare function isStringType(schema: FormSchema): boolean;
+export declare function isNumberType(schema: FormSchema): boolean;
+export declare function isIntegerType(schema: FormSchema): boolean;
 //# sourceMappingURL=schema.d.ts.map

package/dist/types/components/form/templates/array-field-collapsible-item.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { ArrayFieldItem } from './types';
+import { JSONSchema7 } from 'json-schema';
 interface CollapsibleItemProps {
   /**
    * Data from reach-jsonschema-form
@@ -16,11 +17,11 @@ interface CollapsibleItemProps {
   /**
    * Schema for the field
    */
-  schema: any;
+  schema: JSONSchema7;
   /**
    * Schema for the entire form
    */
-  formSchema: any;
+  formSchema: JSONSchema7;
 }
 export declare class CollapsibleItemTemplate extends React.Component {
   props: CollapsibleItemProps;

package/dist/types/components/form/templates/common.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { JSONSchema7 } from 'json-schema';
 export declare function renderTitle(title: string): React.DetailedReactHTMLElement<{
   className: string;
 }, HTMLElement>;
@@ -17,5 +18,5 @@ export declare function renderDescription(description: string): React.DetailedRe
  * @param formSchema - schema for the form
  * @returns describing title of the data
  */
-export declare function findTitle(data: any, fieldSchema: any, formSchema: any): any;
+export declare function findTitle(data: any, fieldSchema: JSONSchema7, formSchema: JSONSchema7): any;
 //# sourceMappingURL=common.d.ts.map

package/dist/types/components/form/templates/types.d.ts

@@ -1,11 +1,11 @@
 import { ObjectFieldTemplateProps, ArrayFieldTemplateProps } from '@rjsf/core';
-import { FormSchema } from '../form.types';
+import { JSONSchema7 } from 'json-schema';
 export { FieldTemplateProps, ArrayFieldTemplateProps } from '@rjsf/core';
 export type TemplateProps = ObjectFieldTemplateProps | ArrayFieldTemplateProps;
 export type ObjectFieldProperty = ObjectFieldTemplateProps['properties'][0];
 export type ArrayFieldItem = ArrayFieldTemplateProps['items'][0];
 export interface LimeObjectFieldTemplateProps extends ObjectFieldTemplateProps {
-  schema: FormSchema;
+  schema: JSONSchema7;
 }
 export interface Runnable {
   run: (event: any) => void;

package/dist/types/interface.d.ts

@@ -11,7 +11,7 @@ export * from './components/dialog/dialog.types';
 export * from './components/dock/dock.types';
 export * from './components/file/file.types';
 export * from './components/flex-container/flex-container.types';
-export * from './components/form/form.types';
+export { EventEmitter, ValidationStatus, FormError, ValidationError, FormComponent, FormInfo, LimeSchemaOptions, LimeLayoutOptions, FormComponentOptions, FormLayoutOptions, GridLayoutOptions, RowLayoutOptions, FormLayoutType, ReplaceObjectType, FormSchemaArrayItem, FormSubKeySchema, } from './components/form/form.types';
 export * from './components/help/help.types';
 export * from './components/icon/icon.types';
 export * from './components/info-tile/info-tile.types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-elements",
-  "version": "37.7.1",
+  "version": "37.8.1",
   "description": "Lime Elements",
   "author": "Lime Technologies",
   "license": "Apache-2.0",
@@ -54,8 +54,8 @@
     "@types/html-escaper": "^3.0.2",
     "@types/jest": "^27.4.0",
     "@types/lodash-es": "^4.17.12",
-    "@types/react": "^18.2.62",
-    "@types/react-dom": "^18.2.19",
+    "@types/react": "^18.2.63",
+    "@types/react-dom": "^18.2.20",
     "@types/tabulator-tables": "^4.9.4",
     "@typescript-eslint/eslint-plugin": "^7.1.1",
     "@typescript-eslint/parser": "^7.1.1",