@ekzo-dev/bootstrap-addons 5.3.10 → 5.3.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ekzo-dev/bootstrap-addons",
   "description": "Aurelia Bootstrap additional component",
-  "version": "5.3.10",
+  "version": "5.3.12",
   "homepage": "https://github.com/ekzo-dev/aurelia-components/tree/main/packages/bootstrap-addons",
   "repository": {
     "type": "git",
@@ -10,20 +10,20 @@
   "license": "MIT",
   "dependencies": {
     "@ekzo-dev/bootstrap": "~5.3.0",
-    "@ekzo-dev/vanilla-jsoneditor": "^3.10.0",
+    "@ekzo-dev/vanilla-jsoneditor": "~3.11.0",
     "@ekzo-dev/toolkit": "^1.2.4",
-    "@fortawesome/free-solid-svg-icons": "^6.5.2",
+    "@fortawesome/free-solid-svg-icons": "^7.0.1",
     "@types/json-schema": "^7.0.14",
     "@js-temporal/polyfill": "^0.5.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "json-schema-library": "^10.5.1"
+    "json-schema-library": "^10.5.2"
   },
   "peerDependencies": {
     "aurelia": "^2.0.0-rc.0",
     "bootstrap": "~5.3.7",
     "@popperjs/core": "^2.11.8",
-    "vanilla-jsoneditor": "~3.7.0",
+    "vanilla-jsoneditor": "~3.11.0",
     "immutable-json-patch": "^6.0.1"
   },
   "main": "src/index.ts",

package/src/forms/duration-input/duration-input.ts

@@ -23,20 +23,20 @@ type DurationLabels = {
 export class BsDurationInput extends BaseField implements EventListenerObject {
   @bindable({ mode: BindingMode.twoWay })
   get value(): string {
-    const { years, months, days, hours, minutes, seconds } = this.duration;
-
-    return Temporal.Duration.from({
-      // at least one field must be present for correct formatting
-      years: years ?? 0,
-      months,
-      days,
-      hours,
-      minutes,
-      seconds,
-    }).toString();
+    const { duration } = this;
+
+    if (Object.values(duration).every((v) => v == null || v.toString() === '')) {
+      return '';
+    }
+
+    return Temporal.Duration.from(duration).toString();
   }
   set value(value: unknown) {
-    this._parseDuration(value);
+    if (value == null || value === '') {
+      this.duration = {};
+    } else {
+      this._parseDuration(value.toString());
+    }
   }
 
   @bindable()
@@ -97,15 +97,9 @@ export class BsDurationInput extends BaseField implements EventListenerObject {
     this.controls.item(0).focus();
   }
 
-  private _parseDuration(value: unknown) {
-    if (value == null || value === '') {
-      this.duration = {};
-
-      return;
-    }
-
+  private _parseDuration(value: string) {
     try {
-      const duration = Temporal.Duration.from(value.toString());
+      const duration = Temporal.Duration.from(value);
 
       this.duration = {
         years: duration.years,

package/src/forms/json-input/json-input.ts

@@ -17,16 +17,17 @@ import type {
   Validator,
 } from 'vanilla-jsoneditor';
 
+import { ProxyObservable } from '@aurelia/runtime';
 import { coerceBoolean } from '@ekzo-dev/toolkit';
 import { JsonEditor } from '@ekzo-dev/vanilla-jsoneditor';
 import { faUpRightAndDownLeftFromCenter } from '@fortawesome/free-solid-svg-icons/faUpRightAndDownLeftFromCenter';
-import Ajv, { ErrorObject, Options, ValidateFunction } from 'ajv';
+import Ajv, { ErrorObject, Options } from 'ajv';
 import Ajv2019 from 'ajv/dist/2019';
 import Ajv2020 from 'ajv/dist/2020';
 import addFormats from 'ajv-formats';
 import { bindable, BindingMode, customElement } from 'aurelia';
 import { parsePath } from 'immutable-json-patch';
-import { compileSchema, JsonError, JsonSchema, SchemaNode } from 'json-schema-library';
+import { CompileOptions, compileSchema, JsonError, SchemaNode } from 'json-schema-library';
 
 const patternMap: Record<string, string> = {
   '^[A-Za-z_][-A-Za-z0-9._]*$': '^[A-Za-z_][\\-A-Za-z0-9._]*$',
@@ -48,11 +49,11 @@ export class BsJsonInput {
   @bindable(coerceBoolean)
   disabled: boolean = false;
 
-  @bindable({ set: (v) => (v === '' || v === true || v === 'true' ? true : v) })
-  jsonSchema?: JSONSchema | boolean;
+  @bindable({ set: (v: BsJsonInput['jsonSchema'] | string) => (v === '' || v === true || v === 'true' ? true : v) })
+  jsonSchema?: JSONSchema | SchemaNode | boolean;
 
   @bindable()
-  ajvOptions: Options = {};
+  validatorOptions?: CompileOptions;
 
   @bindable()
   jsonEditorOptions: JSONEditorPropsOptional = {};
@@ -148,52 +149,24 @@ export class BsJsonInput {
   }
 
   get validator(): Validator | undefined {
-    const { schemaVersion, disabled, ajvOptions, jsonSchema } = this;
-    // use raw object because proxies don't work with private properties
-    const rawThis = this['__raw__'] as BsJsonInput;
-    // use jsonSchema from raw object to pass original (non-proxied) object to AJV
-    const { jsonSchema: rawJsonSchema } = rawThis;
+    const { schemaVersion, disabled, jsonSchema } = this;
+    const rawThis = ProxyObservable.getRaw<BsJsonInput>(this);
 
-    if (jsonSchema && typeof jsonSchema === 'object' && !disabled) {
-      const ajv = rawThis.#initAjv(jsonSchema.$schema as string, ajvOptions);
+    if (disabled) return;
 
-      addFormats(ajv);
-      let validate: ValidateFunction;
-      let schema: SchemaNode;
-
-      try {
-        schema = compileSchema(rawJsonSchema as JsonSchema);
-      } catch (e) {
-        console.error('json-schema-library validator compilation error', e);
-      }
-
-      try {
-        validate = ajv.compile(rawJsonSchema);
-      } catch (e) {
-        console.error('AJV validator compilation error', e);
-      }
+    if (jsonSchema && typeof jsonSchema === 'object') {
+      const schema = rawThis.#initJsonSchemaLibrary();
 
       return (json: unknown): ValidationError[] => {
         // do not validate empty documents
-        if (json === undefined) return [];
+        if (json === undefined || !schema) return [];
 
-        let allErrors: ValidationError[] = [];
-
-        if (schema) {
-          const { errors } = schema.validate(json);
-
-          allErrors = rawThis.#processErrors(errors, json);
-        }
+        const { errors } = schema.validate(json);
 
-        if (validate) {
-          validate(json);
-          allErrors = allErrors.concat(rawThis.#processErrorsAjv(validate.errors, json));
-        }
-
-        return allErrors;
+        return rawThis.#processErrors(errors, json);
       };
-    } else if (schemaVersion != null && !disabled) {
-      const ajv = rawThis.#initAjv(schemaVersion, ajvOptions);
+    } else if (schemaVersion != null) {
+      const ajv = rawThis.#initAjv(schemaVersion);
 
       return (json: unknown): ValidationError[] => {
         // do not validate empty documents
@@ -216,7 +189,7 @@ export class BsJsonInput {
     }
   }
 
-  #initAjv($schema: string, ajvOptions: Options): Ajv {
+  #initAjv($schema: string): Ajv {
     // some regexp's in 2019-09/2020-12 meta-schemas are not compatible with 'v' flag, so update them
     const regExp = (pattern: string) => new RegExp(patternMap[pattern] ?? pattern, 'v');
 
@@ -228,7 +201,7 @@ export class BsJsonInput {
       code: {
         regExp,
       },
-      ...ajvOptions,
+      allErrors: true,
     };
     let ajv: Ajv;
 
@@ -245,9 +218,28 @@ export class BsJsonInput {
         ajv = new Ajv(options);
     }
 
+    addFormats(ajv);
+
     return ajv;
   }
 
+  #initJsonSchemaLibrary(): SchemaNode | undefined {
+    const { jsonSchema } = this;
+
+    // already a SchemaNode
+    if ((jsonSchema as SchemaNode).evaluationPath) {
+      return jsonSchema as SchemaNode;
+    }
+
+    try {
+      return compileSchema(jsonSchema as JSONSchema, this.validatorOptions);
+    } catch (e) {
+      console.error('json-schema-library validator compilation error', e);
+
+      return;
+    }
+  }
+
   #getSchemaDefinitions(schema: JSONSchema): JSONSchemaDefinitions {
     return (schema.$defs ?? schema.definitions) as JSONSchemaDefinitions;
   }
@@ -272,7 +264,7 @@ export class BsJsonInput {
     return (errors || []).map((error) => ({
       path: parsePath(json, error.data.pointer),
       message: error.message || 'Unknown error',
-      severity: 'error' as ValidationSeverity,
+      severity: 'warning' as ValidationSeverity,
     }));
   }
 }