@zohodesk/library-platform 1.1.9 → 1.1.10-exp.2

package/es/library/custom-component/domain/entities/Logger.js

@@ -0,0 +1,93 @@
+import { ErrorCodes } from "../../../../cc/component/ErrorStructure";
+// const ERROR_TITLE: string = 'color: red; font-weight: bold;';
+const ERROR_PRIMARY = 'color: #FF6F61;font-weight: bold';
+const ERROR_SECONDARY = 'color: #FFA500;font-weight: initial'; // const LOG_TITLE: string = 'color: gray; font-weight: bold;';
+
+const LOG_PRIMARY = 'color: #55c355;font-weight: bold';
+const LOG_SECONDARY = 'color: #5a9de9;font-weight: bold';
+export default class Logger {
+  constructor(componentName) {
+    this.componentName = componentName;
+  } // eslint-disable-next-line max-lines-per-function
+
+
+  logPropertiesValidation(validationResults) {
+    console.group(`%cProperties Validation: %c${this.componentName}`, ERROR_PRIMARY, ERROR_SECONDARY, validationResults);
+    validationResults.forEach(_ref => {
+      let {
+        key,
+        errors,
+        warnings,
+        value
+      } = _ref;
+      errors?.forEach(error => {
+        this.printResult(key, error, 'error');
+      });
+      warnings?.forEach(warning => {
+        this.printResult(key, warning, 'warning');
+      });
+      console.log('%cBut, Given is:', 'color: white;font-weight: bold;', {
+        [key]: value
+      });
+    });
+    console.groupEnd();
+  }
+
+  logError(error) {
+    console.log('Logging Error in ComponentProperties - logError');
+
+    if (error.code === ErrorCodes.PROPERTY_VALIDATION_FAILED) {
+      this.logPropertiesValidation(error.errorDetails?.validationResults);
+      return;
+    }
+
+    console.group(`%cError Occurred: %c${this.componentName}`, ERROR_PRIMARY, ERROR_SECONDARY, error);
+    console.error(`%cError Code: %c${error.code}`, ERROR_PRIMARY, ERROR_SECONDARY);
+    console.error(`%cError Message: %c${error.message}`, ERROR_PRIMARY, ERROR_SECONDARY);
+
+    if (error.errorDetails?.originalError) {
+      console.error(error.errorDetails.originalError);
+    }
+
+    console.groupEnd();
+  }
+
+  printResult(key, errorOrWarning, type) {
+    const log = type === 'error' ? console.error : console.warn;
+
+    if (errorOrWarning.dataPath) {
+      log(`Invalid Property %c${key}%c${errorOrWarning.dataPath} %c${errorOrWarning.message}`, ERROR_PRIMARY, ERROR_SECONDARY, 'color: white;');
+      return;
+    }
+
+    log(`Invalid Property %c${key} : %c${errorOrWarning.message}`, ERROR_PRIMARY, 'color: white;');
+  }
+
+  eventNameConsoleStyle(type) {
+    const index = type.indexOf('#');
+    return {
+      msg: '%c' + type.slice(0, index) + '%c' + type.slice(index),
+      styles: [LOG_PRIMARY, LOG_SECONDARY]
+    };
+  }
+
+  isLoggingEnabled() {
+    // @ts-ignore
+    return __DEVELOPMENT__ && globalThis.enableEventLogging;
+  }
+
+  isLoggingEnabledAndTypePresent(type) {
+    return this.isLoggingEnabled() && type;
+  }
+
+  logEvent(type, data) {
+    if (this.isLoggingEnabledAndTypePresent(type)) {
+      const {
+        msg,
+        styles: nameStyles
+      } = this.eventNameConsoleStyle(type);
+      console.log(`%cEvent ${msg}`, 'font-weight: bold', ...nameStyles, data);
+    }
+  }
+
+}

package/es/library/custom-component/domain/entities/Payload.js

@@ -1,11 +1,5 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 export default class Payload {
   constructor(name, typeMetadata) {
-    _defineProperty(this, "name", void 0);
-
-    _defineProperty(this, "typeMetadata", void 0);
-
     this.name = name;
     this.typeMetadata = typeMetadata;
   }

package/es/library/custom-component/domain/entities/Properties.js

@@ -1,5 +1,3 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import Property from "./Property";
 import defaultAppendToActionPayload from "./DefaultAppendToActionPayload";
 import getRefPropertySchema from "../../../../cc/component/properties/getRefPropertySchema";
@@ -7,13 +5,10 @@ import defaultSlotNameAppend from "./DefaultSlotNameAppend";
 export default class Properties {
   constructor(properties, componentName) {
     this.componentName = componentName;
-
-    _defineProperty(this, "data", void 0);
-
     this.data = properties;
     this.data.set('appendToActionPayload', new Property(defaultAppendToActionPayload));
     this.data.set('getRef', new Property(getRefPropertySchema));
-    typeof properties.get("slotName") === "undefined" && this.data.set('slotName', new Property(defaultSlotNameAppend));
+    typeof properties.get('slotName') === 'undefined' && this.data.set('slotName', new Property(defaultSlotNameAppend));
   }
 
   getAllPropertiesValue() {
@@ -25,152 +20,25 @@ export default class Properties {
 
     return convertedObject;
   }
-  /* break value object*/
-
-
-  updateAllPropertiesValue(validator, propertyValue) {
-    // this.validateProperties(validator, propertyValue);
-    if (!this.isEqual(propertyValue)) {
-      let isChanged = false;
-      Object.keys(propertyValue).forEach(key => {
-        let property = this.findProperty(key);
-
-        if (property.getValue() == null || property.getValue() == undefined) {
-          // property.updateValue(propertyValue[key]);
-          isChanged = true;
-        } else if (property.getValue() != propertyValue[key]) {
-          // property.updateValue(propertyValue[key]);
-          isChanged = true;
-        }
-      });
-      return isChanged;
-    }
 
-    return false;
+  getAllPropertiesKeys() {
+    return Array.from(this.data.keys());
   }
 
-  isEqual(newProps) {
-    let isShallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-
-    if (isShallow) {
-      return this.shallowCompareWithNewObject(newProps);
-    }
-
-    return false;
+  findProperty(key) {
+    return this.data.get(key);
   }
 
-  validateProperties(validator, newProps) {
-    let errors = [];
-    Object.keys(newProps).forEach(key => {
-      this.validate(validator, key, newProps[key], errors);
+  getPropertiesClone() {
+    const clonedMap = {};
+    this.data.forEach(obj => {
+      clonedMap[obj.getName()] = obj.clone();
     });
-
-    if (errors.length > 0) {
-      this.handleValidationErrors(errors);
-    }
-
-    return true;
-  }
-
-  validate(validator, key, value, errors) {
-    if (!this.data.has(key)) {
-      throw new Error(this.componentName + ` props '${key}' not exist `);
-    }
-
-    let property = this.data.get(key);
-    let schema = property.getTypeMetadata().schema;
-    let isValid;
-
-    try {
-      isValid = validator(schema, value);
-    } catch (error) {
-      isValid = false;
-    }
-
-    if (!isValid) {
-      const error = {
-        key: key,
-        componentName: this.componentName,
-        value: value,
-        schema: schema
-      };
-      errors.push(error);
-    }
-  }
-
-  handleValidationErrors(errors) {
-    console.log('Property validation failed', this.componentName, errors);
-    throw new Error('Property validation failed');
-  }
-
-  getSchema(key, optionalSchema) {
-    if (optionalSchema) {
-      return optionalSchema;
-    }
-
-    return this.data.get(key).getTypeMetadata().schema;
-  }
-
-  validateRequiredProperty(validator, properties, newProps) {
-    let errorWarn = validator(properties, newProps);
-    let isErrorVisible = false;
-
-    if (errorWarn.warnings && errorWarn.warnings.length > 0) {
-      errorWarn.warnings.forEach(warning => {
-        console.warn(`%c Property Validation Warnings in %c ${this.componentName}%c :\n${warning}`, 'font-weight: initial', 'color: #FF6F61;font-weight: bold', 'color: #FFA500;font-weight: initial');
-      });
-    }
-
-    if (errorWarn.errors && errorWarn.errors.length > 0) {
-      console.error(`%c Property Validation Errors in %c ${this.componentName}%c :\n${errorWarn.errors.join('\n')}`, 'font-weight: initial', 'color: #FF6F61;font-weight: bold', 'color: #FFF;font-weight: initial');
-      isErrorVisible = true;
-    }
-
-    return isErrorVisible;
-  }
-
-  validateSingleProperty(validator, onePropKey, onePropValue, optionalSchema) {
-    let schema = this.getSchema(onePropKey, optionalSchema); // INFO: Validate the property adheres to its schema
-
-    const {
-      isValid,
-      errors
-    } = validator(schema, onePropValue);
-
-    if (!isValid) {
-      const error = {
-        key: onePropKey,
-        componentName: this.componentName,
-        value: onePropValue,
-        isValid,
-        errors,
-        schema: schema
-      };
-      console.error('Property validation failed', error);
-      throw new Error('Property validation failed');
-    }
-
-    return true;
-  }
-
-  findProperty(key) {
-    return this.data.get(key);
+    return clonedMap;
   }
 
   getAppendToActionPayloadProperty() {
     return this.data.get('appendToActionPayload').getValue();
   }
 
-  shallowCompareWithNewObject(obj1) {
-    const keys1 = Object.keys(obj1);
-
-    for (let key of keys1) {
-      if (!this.data.has(key) || obj1[key] !== this.data.get(key).getValue()) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
 }

package/es/library/custom-component/domain/entities/Property.js

@@ -1,5 +1,4 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+/* eslint-disable complexity */
 export default class Property {
   constructor(_ref) {
     let {
@@ -8,17 +7,6 @@ export default class Property {
       required,
       typeMetadata
     } = _ref;
-
-    _defineProperty(this, "name", void 0);
-
-    _defineProperty(this, "required", void 0);
-
-    _defineProperty(this, "defaultValue", void 0);
-
-    _defineProperty(this, "typeMetadata", void 0);
-
-    _defineProperty(this, "value", void 0);
-
     this.name = name;
     this.defaultValue = defaultValue;
     this.required = required;
@@ -53,6 +41,34 @@ export default class Property {
     return isChanged;
   }
 
+  getSchemaForValidation(value) {
+    return {
+      required: this.required,
+      isValueProvided: value !== undefined,
+      defaultValue: this.defaultValue,
+      name: this.name,
+      schema: this.getTypeMetadata().schema
+    };
+  }
+
+  validateProperty(validator, value) {
+    const propertySchema = this.getSchemaForValidation(value);
+    const propertyValue = !propertySchema.isValueProvided ? this.getDefaultValue() : value;
+    const {
+      isValid,
+      errors,
+      warnings
+    } = validator(propertySchema, propertyValue);
+    return {
+      key: this.name,
+      isValid,
+      errors,
+      warnings,
+      schema: propertySchema,
+      value: propertyValue
+    };
+  }
+
   clone() {
     return new Property({
       name: this.name,

package/es/library/custom-component/domain/entities/Schema.js

@@ -1,9 +1,5 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class Schema {
-  constructor() {
-    _defineProperty(this, "_type", void 0);
-  }
+  constructor() {}
 
   getType() {
     return this._type;

package/es/library/custom-component/domain/entities/State.js

@@ -1,9 +1,5 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 export default class State {
   constructor() {
-    _defineProperty(this, "state", void 0);
-
     this.state = {};
   }
 

package/es/library/custom-component/domain/entities/Style.js

@@ -1,18 +1,4 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 export default class Style {
-  constructor() {
-    _defineProperty(this, "name", void 0);
-
-    _defineProperty(this, "label", void 0);
-
-    _defineProperty(this, "required", void 0);
-
-    _defineProperty(this, "defaultValue", void 0);
-
-    _defineProperty(this, "typeMetadata", void 0);
-  }
-
   getLabel() {
     return this.label;
   }

package/es/library/custom-component/frameworks/json-schema-validator/Validator.js

@@ -1,3 +1,4 @@
+/* eslint-disable complexity */
 import Ajv from 'ajv';
 let jsonValidator = new Ajv({
   useDefaults: true
@@ -5,57 +6,154 @@ let jsonValidator = new Ajv({
 
 class Validator {
   static validate(schema, value) {
-    let errors = [];
+    if (schema.schema) {
+      return Validator.validatePropertySchema(schema, value);
+    }
 
-    if (schema.type === 'function' && typeof value === 'function') {
-      return {
-        isValid: true,
-        errors
-      };
-    } // validate is a type guard for MyData - type is inferred from schema type
+    let errors = [];
+    Validator.checkFunctionsRecursively(schema, value, '', '#', errors); // Use AJV for the rest of the validation, ignoring functions
 
+    const ajvSchema = JSON.parse(JSON.stringify(schema, (key, val) => val === 'function' ? undefined : val)); // validate is a type guard for MyData - type is inferred from schema type
+    // const validate = jsonValidator.compile(schema);
 
-    const validate = jsonValidator.compile(schema);
+    const validate = jsonValidator.compile(ajvSchema);
     const isValid = validate(value);
 
     if (!isValid) {
-      errors = validate.errors;
+      // errors = validate.errors;
+      validate.errors && errors.push(...validate.errors);
+    }
+
+    return {
+      isValid: isValid && errors.length === 0,
+      errors,
+      warnings: []
+    };
+  }
+
+  static checkFunctionsRecursively(schema, value) {
+    let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    let schemaPath = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '#';
+    let errors = arguments.length > 4 ? arguments[4] : undefined;
+
+    if (schema.type === 'function') {
+      if (typeof value !== 'function') {
+        errors.push({
+          keyword: 'type',
+          dataPath: path ? `.${path}` : '',
+          schemaPath: `${schemaPath}/type`,
+          params: {
+            type: 'function'
+          },
+          message: 'should be function'
+        });
+      }
+
+      return;
+    }
+
+    if (schema.type === 'object' && schema.properties && typeof value === 'object' && value !== null) {
+      for (const key in schema.properties) {
+        Validator.checkFunctionsRecursively(schema.properties[key], value[key], path ? `${path}.${key}` : key, `${schemaPath}/properties/${key}`, errors);
+      }
     }
 
+    if (schema.type === 'array' && Array.isArray(value) && schema.items) {
+      value.forEach((item, index) => {
+        Validator.checkFunctionsRecursively(schema.items, item, `${path}[${index}]`, `${schemaPath}/items`, errors);
+      });
+    } // if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    //   const subErrors = [];
+    //   const valid = schema.anyOf.some((subSchema, idx) => {
+    //     const tmpErrors = [];
+    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/anyOf/${idx}`, tmpErrors);
+    //     return tmpErrors.length === 0;
+    //   });
+    //   if (!valid) {
+    //     errors.push({ keyword: "anyOf", dataPath: path ? `.${path}` : "", schemaPath: `${schemaPath}/anyOf`, params: {}, message: "should match some schema in anyOf" });
+    //   }
+    //   return;
+    // }
+    // if (schema.allOf && Array.isArray(schema.allOf)) {
+    //   schema.allOf.forEach((subSchema, idx) => {
+    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/allOf/${idx}`, errors);
+    //   });
+    //   return;
+    // }
+    // if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    //   let matchCount = 0;
+    //   schema.oneOf.forEach((subSchema, idx) => {
+    //     const tmpErrors = [];
+    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/oneOf/${idx}`, tmpErrors);
+    //     if (tmpErrors.length === 0) matchCount++;
+    //   });
+    //   if (matchCount !== 1) {
+    //     errors.push({ keyword: "oneOf", dataPath: path ? `.${path}` : "", schemaPath: `${schemaPath}/oneOf`, params: {}, message: "should match exactly one schema in oneOf" });
+    //   }
+    //   return;
+    // }
+
+  }
+
+  static validatePropertySchema(propertySchema, value) {
+    const {
+      schema
+    } = propertySchema;
+    const result = Validator.validateRequired(propertySchema, value);
+    const isProvided = propertySchema.isValueProvided;
+
+    if (result.isValid === false) {
+      return result;
+    }
+
+    if (!isProvided) {
+      return {
+        isValid: true,
+        errors: [],
+        warnings: result.warnings
+      };
+    }
+
+    const {
+      isValid,
+      errors,
+      warnings
+    } = Validator.validate(schema, value);
     return {
+      key: propertySchema.name,
       isValid,
-      errors
+      errors,
+      warnings: [...result.warnings, ...warnings]
     };
   }
 
-  static validatePropsAgainstSchema(schemaProps, props) {
-    const warnings = [];
+  static validateRequired(propertySchema, value) {
     const errors = [];
+    const warnings = [];
+    const isRequired = propertySchema.required === true;
+    const hasDefault = Object.prototype.hasOwnProperty.call(propertySchema, 'defaultValue');
+    const isProvided = propertySchema.isValueProvided;
 
-    for (const key in schemaProps) {
-      const schemaDef = schemaProps[key];
-      const isRequired = schemaDef.required === true;
-      const hasDefault = Object.prototype.hasOwnProperty.call(schemaDef, 'defaultValue');
-      const isProvided = Object.prototype.hasOwnProperty.call(props, key); // Handle missing required top-level properties
-
-      if (!isProvided) {
-        if (isRequired) {
-          if (hasDefault) {
-            if (schemaDef.defaultValue === undefined) {
-              errors.push(`Required property '${key}' is missing — default value is undefined.`);
-            } else {
-              warnings.push(`Required property '${key}' is missing. Default value will be used.`);
-            }
-          } else {
-            errors.push(`Required property '${key}' is missing — neither a value nor a default value is present.`);
-          }
+    if (!isProvided && isRequired) {
+      if (hasDefault) {
+        if (propertySchema.defaultValue === undefined) {
+          errors.push({
+            message: `is required but missing. So, default value is undefined.`
+          });
+        } else {
+          warnings.push({
+            message: `is required but missing. So, Default value will be used.`
+          });
         }
-
-        continue;
+      } else {
+        errors.push({
+          message: `is required but missing. And, neither a value nor a default value is present.`
+        });
       }
     }
 
     return {
+      isValid: errors.length === 0,
       warnings,
       errors
     };

package/es/library/custom-component/frameworks/ui/ComponentRegistry.js

@@ -1,9 +1,7 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class ComponentRegistry {
-  constructor() {
-    _defineProperty(this, "components", new Map());
-  }
+  components = new Map();
+
+  constructor() {}
 
   static getInstance() {
     if (!ComponentRegistry.instance) {
@@ -31,6 +29,4 @@ class ComponentRegistry {
 
 }
 
-_defineProperty(ComponentRegistry, "instance", void 0);
-
 export default ComponentRegistry.getInstance();