@zohodesk/library-platform 1.1.9-alpha.1 → 1.1.9-exp.1

package/es/bc/app-context/Event.js

@@ -0,0 +1 @@
+export default [];

package/es/bc/app-context/Properties.js

@@ -0,0 +1,58 @@
+export default {
+  context: {
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'object',
+        properties: {
+          orgId: {
+            type: 'string'
+          },
+          // zlist
+          orgName: {
+            type: 'string'
+          },
+          // zlist, zform
+          servicePrefix: {
+            type: 'string'
+          },
+          // zlist, zform
+          modules: {
+            // zlist
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                apiKey: {
+                  type: 'string'
+                },
+                hasRecycleBin: {
+                  type: 'boolean'
+                },
+                nameField: {
+                  type: 'string'
+                }
+              } // required: ['apiKey', 'nameField'] 
+              // NOTE: making required should handled inside AppContextBehaviourFactory in future if needed
+
+            }
+          },
+          departmentName: {
+            type: 'string'
+          },
+          // zlist
+          routing: {
+            type: 'object'
+          },
+          // zlist
+          additionalData: {
+            type: 'object'
+          } // zform
+
+        },
+        // required: ['orgName'],
+        additionalProperties: false
+      }
+    }
+  }
+};

package/es/bc/zform/Properties.js

@@ -61,6 +61,12 @@ export default {
           servicePrefix: {
             type: 'string'
           },
+          currencyLocale: {
+            type: 'string'
+          },
+          currencySymbol: {
+            type: 'string'
+          },
           additionalData: {
             type: 'object'
           }

package/es/bc/zlist/Properties.js

@@ -44,6 +44,12 @@ export default {
           orgName: {
             type: 'string'
           },
+          currencyLocale: {
+            type: 'string'
+          },
+          currencySymbol: {
+            type: 'string'
+          },
           modules: {
             type: 'array',
             items: {

package/es/cc/component/ErrorStructure.js

@@ -0,0 +1,9 @@
+export let ErrorCodes = /*#__PURE__*/function (ErrorCodes) {
+  ErrorCodes["PROPERTY_VALIDATION_FAILED"] = "PROPERTY_VALIDATION_FAILED";
+  ErrorCodes["API_FAILED"] = "API_FAILED";
+  ErrorCodes["EVENT_HANDLER_FAILED"] = "EVENT_HANDLER_FAILED";
+  ErrorCodes["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return ErrorCodes;
+}({});
+export const ACA_ERROR_OCCURRED = 'ACA#ERROR_OCCURRED';
+export const ERROR_OCCURRED_SUFFIX = '#ERROR_OCCURRED';

package/es/cc/error-state/ErrorTypes.js

@@ -0,0 +1,11 @@
+var ErrorTypes = /*#__PURE__*/function (ErrorTypes) {
+  ErrorTypes["Inconvenience"] = "Inconvenience";
+  ErrorTypes["OopsSomethingMiss"] = "OopsSomethingMiss";
+  ErrorTypes["UnableToProcess"] = "UnableToProcess";
+  ErrorTypes["PermissionDenied"] = "PermissionDenied";
+  ErrorTypes["UrlNotFound"] = "UrlNotFound";
+  ErrorTypes["WillBeRightBack"] = "WillBeRightBack";
+  return ErrorTypes;
+}(ErrorTypes || {});
+
+export default ErrorTypes;

package/es/cc/error-state/Properties.js

@@ -0,0 +1,31 @@
+import ErrorTypes from "./ErrorTypes";
+export default {
+  type: {
+    defaultValue: ErrorTypes.OopsSomethingMiss,
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: Object.values(ErrorTypes)
+      }
+    }
+  },
+  title: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    }
+  },
+  description: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    }
+  }
+};

package/es/cc/error-state/index.js

@@ -0,0 +1,2 @@
+export { default as ErrorStateProperties } from "./Properties";
+export { default as ErrorStateTypes } from "./ErrorTypes";

package/es/cc/fields/currency/Model.js

@@ -2,6 +2,7 @@ export default function CurrencyFieldModel(_ref) {
   let {
     name,
     currencyLocale,
+    currencySymbol,
     value,
     uiType,
     appendToActionPayload
@@ -9,6 +10,7 @@ export default function CurrencyFieldModel(_ref) {
   return {
     name,
     currencyLocale,
+    currencySymbol,
     appendToActionPayload,
     type: uiType,
     value

package/es/cc/fields/text/Properties.js

@@ -29,7 +29,7 @@ export default { ...FieldProperties,
   },
   lookup: {
     required: false,
-    defaultValue: '',
+    defaultValue: {},
     typeMetadata: {
       schema: {
         type: 'object'

package/es/cc/form-connected/ExternalConstants.js

@@ -0,0 +1,11 @@
+class SmartFormConstants {
+  static SMART_FORM_FIELD_FOCUSED = 'SMART_FORM#FIELD_FOCUSED';
+  static SMART_FORM_FIELD_BLURRED = 'SMART_FORM#FIELD_BLURRED';
+  static SMART_FORM_FIELD_VALUE_CHANGED = 'SMART_FORM#FIELD_VALUE_CHANGED';
+  static SMART_FORM_SUBMIT_CLICKED = 'SMART_FORM#SUBMIT_CLICKED';
+  static SMART_FORM_CANCEL_CLICKED = 'SMART_FORM#CANCEL_CLICKED';
+  static SMART_FORM_SUBMIT_SUCCESS = 'SMART_FORM#SUBMIT_SUCCESS';
+  static SMART_FORM_SUBMIT_FAILURE = 'SMART_FORM#SUBMIT_FAILED';
+}
+
+export default SmartFormConstants;

package/es/cc/form-connected/index.js

@@ -1,2 +1,2 @@
 // export { ErrorCode as SmartFormErrorCode } from './ErrorEventType';
-export { default as SmartFormConstants } from "./Constants"; // export { default as SmartFormEventsContracts } from './Events';
+export { default as SmartFormConstants } from "./ExternalConstants"; // export { default as SmartFormEventsContracts } from './Events';

package/es/cc/switch/Properties.js

@@ -19,11 +19,11 @@ export default {
   },
   size: {
     required: true,
-    defaultValue: "small",
+    defaultValue: "medium",
     typeMetadata: {
       schema: {
         type: "string",
-        enum: ["small", "medium"]
+        enum: ["small", "medium", "large", "xlarge"]
       }
     }
   },

package/es/cc/table-connected/Events.js

@@ -1,5 +1,5 @@
 import { ZListEvents } from "../../bc/zlist";
-import SmartTableEventConstants from "./constants/Events";
+import SmartTableEventConstants from "./constants/ExternalConstants";
 const {
   DELETE_RECORDS_SUCCESS,
   UPDATE_RECORDS_SUCCESS,

package/es/cc/table-connected/Properties.js

@@ -25,6 +25,12 @@ export default {
               properties: {
                 initialWidth: {
                   type: 'number'
+                },
+                currencyLocale: {
+                  type: 'string'
+                },
+                currencySymbol: {
+                  type: 'string'
                 }
               }
             }

package/es/cc/table-connected/constants/Events.js

@@ -1,15 +1,8 @@
 export const ERROR_OCCURRED = 'SMART_TABLE#ERROR_OCCURRED';
 export default {
-  REORDER_SUCCESS: 'SMART_TABLE#REORDER_SUCCEED',
-  DELETE_RECORDS_SUCCESS: 'SMART_TABLE#RECORD_DELETED',
-  UPDATE_RECORDS_SUCCESS: 'SMART_TABLE#RECORD_UPDATED',
   SORT: 'SMART_TABLE#SORT',
   SORTED: 'SMART_TABLE#SORTED',
-  RECORDS_SELECTED: 'SMART_TABLE#RECORDS_SELECTED',
-  RECORDS_DESELECTED: 'SMART_TABLE#RECORDS_DESELECTED',
-  SMART_TABLE_ROW_ACTION_TRIGGERED: 'SMART_TABLE#ROW_ACTION_TRIGGERED',
-  ERROR_OCCURRED,
-  SELECTION_LIMIT_EXCEEDED: 'SMART_TABLE#SELECTION_LIMIT_EXCEEDED'
+  ERROR_OCCURRED
 };
 export const SMART_TABLE_SELECTION_TOGGLED = 'SMART_TABLE#SELECTION_TOGGLED';
 export const SMART_TABLE_ACTION_TRIGGERED = 'SMART_TABLE#ACTION_TRIGGERED';

package/es/cc/table-connected/constants/ExternalConstants.js

@@ -0,0 +1,9 @@
+export default {
+  REORDER_SUCCESS: 'SMART_TABLE#REORDER_SUCCEED',
+  DELETE_RECORDS_SUCCESS: 'SMART_TABLE#RECORD_DELETED',
+  UPDATE_RECORDS_SUCCESS: 'SMART_TABLE#RECORD_UPDATED',
+  RECORDS_SELECTED: 'SMART_TABLE#RECORDS_SELECTED',
+  RECORDS_DESELECTED: 'SMART_TABLE#RECORDS_DESELECTED',
+  SMART_TABLE_ROW_ACTION_TRIGGERED: 'SMART_TABLE#ROW_ACTION_TRIGGERED',
+  SELECTION_LIMIT_EXCEEDED: 'SMART_TABLE#SELECTION_LIMIT_EXCEEDED'
+};

package/es/cc/table-connected/constants/index.js

@@ -1 +1,2 @@
-export { default as Events } from "./Events";
+export { default as Events } from "./Events";
+export { default as ExternalConstants } from "./ExternalConstants";

package/es/index.js

@@ -1,5 +1,15 @@
-import * as _CC from "./cc";
-export { _CC as CC };
+// export * as CC from './cc';
+import * as CCNamespace from "./cc"; // Import only the ExternalConstants
+
+import ExternalConstants from "./cc/table-connected/constants/ExternalConstants"; // Rebuild SmartTableConstants without Events
+
+const SmartTableConstants = {
+  ExternalConstants
+}; // Re-export CC, overriding SmartTableConstants
+
+export const CC = { ...CCNamespace,
+  SmartTableConstants
+};
 import * as _BC from "./bc";
 export { _BC as BC };
 export { TableConnectedFactory, FormConnectedFactory } from "./platform/components";

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

@@ -0,0 +1,121 @@
+/* eslint-disable complexity */
+import { ErrorCodes } from "../../../../cc/component/ErrorStructure";
+import Logger from "./Logger";
+export default class ComponentProperties {
+  constructor(componentName, properties, behaviours) {
+    this.componentName = componentName;
+    this.properties = properties;
+    this.behaviours = behaviours;
+    this.logger = new Logger(componentName);
+    this.behavioursProperties = {};
+    /* store behaviour properties */
+
+    this.behaviours.forEach(behaviour => {
+      behaviour.getProperties().data && behaviour.getProperties().data.forEach(obj => {
+        this.behavioursProperties[obj.getName()] = obj.clone();
+      });
+    });
+  }
+
+  getAllBehavioursPropertiesWithValue() {
+    const output = {};
+    Object.keys(this.behavioursProperties).forEach(propertyName => {
+      output[propertyName] = this.behavioursProperties[propertyName].getValue();
+    });
+    return output;
+  }
+
+  getAllPropertiesValue() {
+    return { ...this.properties.getAllPropertiesValue(),
+      ...this.getAllBehavioursPropertiesWithValue()
+    };
+  }
+
+  getAllPropertiesKeys() {
+    const propKeys = this.properties.getAllPropertiesKeys();
+    const bhvrKeys = Object.keys(this.behavioursProperties);
+    return [...propKeys, ...bhvrKeys];
+  }
+
+  validateAndUpdateProperties(jsonValidator, newProps) {
+    const {
+      isValid,
+      validationResults
+    } = this.validateProperties(jsonValidator, newProps);
+
+    if (!isValid) {
+      this.logger.logPropertiesValidation(validationResults); // console.log({ isValid, componentName: this.componentName, validationResults });
+
+      throw {
+        code: ErrorCodes.PROPERTY_VALIDATION_FAILED,
+        message: `Properties validation failed for component ${this.componentName}`,
+        errorDetails: {
+          isBreaking: true,
+          validationResults: validationResults.filter(result => !result.isValid)
+        }
+      };
+    }
+
+    return this.updateProperties(newProps);
+  }
+
+  updateProperties(newProps) {
+    const allProperties = this.getAllPropertiesKeys();
+    let isChanged = false;
+    allProperties.forEach(key => {
+      const property = this.findProperty(key);
+
+      if (property) {
+        isChanged = property.updateValue(newProps[key]) || isChanged;
+      }
+    });
+    return isChanged;
+  }
+
+  getExtraPropertiesError(propertyName) {
+    return {
+      key: propertyName,
+      isValid: false,
+      warnings: [{
+        keyword: 'extra',
+        message: 'Property is not allowed',
+        params: {}
+      }],
+      errors: [],
+      schema: {}
+    };
+  }
+
+  validateProperties(validator, newProps) {
+    const allProperties = this.getAllPropertiesKeys();
+    const validationResults = [];
+    allProperties.forEach(propertyName => {
+      const property = this.findProperty(propertyName);
+
+      if (property) {
+        const result = property.validateProperty(validator, newProps[propertyName]);
+        validationResults.push(result);
+      } else {
+        validationResults.push(this.getExtraPropertiesError(propertyName));
+      }
+    });
+    const isValid = validationResults.every(result => result.isValid);
+    return {
+      isValid,
+      validationResults
+    };
+  }
+
+  findProperty(propertyName) {
+    if (this.behavioursProperties[propertyName]) {
+      return this.behavioursProperties[propertyName];
+    }
+
+    return this.properties.findProperty(propertyName);
+  }
+
+  getAppendToActionPayloadProperty() {
+    return this.properties.getAppendToActionPayloadProperty();
+  }
+
+}

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

@@ -0,0 +1,63 @@
+// Define types
+// 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.filter(result => result.errors?.length > 0 || result.warnings?.length > 0));
+    validationResults.filter(result => result.errors?.length > 0 || result.warnings?.length > 0).forEach(result => {
+      result.errors?.forEach(error => {
+        this.printResult(result.key, error);
+      });
+      result.warnings?.forEach(warning => {
+        this.printResult(result.key, warning);
+      });
+    });
+    console.groupEnd();
+  }
+
+  printResult(key, errorOrWarning) {
+    if (errorOrWarning.dataPath) {
+      console.error(`Invalid Property %c${key}%c${errorOrWarning.dataPath} %c${errorOrWarning.message}`, ERROR_PRIMARY, ERROR_SECONDARY, 'color: white;');
+      return;
+    }
+
+    console.error(`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/frameworks/json-schema-validator/Validator.js

@@ -6,28 +6,89 @@ let jsonValidator = new Ajv({
 class Validator {
   static validate(schema, value) {
     let errors = [];
+    Validator.checkFunctionsRecursively(schema, value, '', '#', errors); // Use AJV for the rest of the validation, ignoring functions
 
-    if (schema.type === 'function' && typeof value === 'function') {
-      return {
-        isValid: true,
-        errors
-      };
-    } // validate is a type guard for MyData - type is inferred from schema type
+    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;
+      errors.push(...(validate.errors || []));
     }
 
     return {
-      isValid,
+      isValid: isValid && errors.length === 0,
       errors
     };
   }
 
+  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 validatePropsAgainstSchema(schemaProps, props) {
     const warnings = [];
     const errors = [];

package/es/library/dot/components/form/frameworks/ui/FormView.js

@@ -20,10 +20,12 @@ function FormView(_ref, ref) {
     isFooterEnabled
   } = state.viewModel;
   return /*#__PURE__*/React.createElement(Flex, {
-    $ui_tagName: "form",
     $ui_displayMode: "flex",
     $ui_direction: "column",
     $flag_fullsize: true,
+    $a11y_attributes: {
+      role: 'form'
+    },
     ref: ref
   }, /*#__PURE__*/React.createElement(Header, {
     hasHeader: isHeaderEnabled,

package/es/library/dot/components/form-fields/currency/frameworks/ui/CurrencyView.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import TextBox from "../../../../../legacy-to-new-arch/textbox/frameworks/ui/TextBox";
-import FieldItem from "../../../field/FieldItem"; // @ts-ignore
+import FieldItem from "../../../field/FieldItem";
+import { formatCurrency } from "../../../../../../translator-common"; // @ts-ignore
 
 import style from "../../../../form/frameworks/ui/css/Form.module.css";
 
@@ -8,6 +9,10 @@ function CurrencyView(_ref, ref) {
   let {
     state
   } = _ref;
+  const {
+    isFocused,
+    properties
+  } = state;
   const {
     id,
     label,
@@ -17,14 +22,21 @@ function CurrencyView(_ref, ref) {
     disabled,
     readonly,
     required,
+    currencyLocale,
+    currencySymbol,
     labelActions,
     actions,
     uiConfig
-  } = state.properties;
+  } = properties;
   const {
     size,
     breakRow
   } = uiConfig;
+  const formattedValue = isFocused ? value : formatCurrency({
+    value,
+    symbol: currencySymbol,
+    locale: currencyLocale
+  });
   return /*#__PURE__*/React.createElement(FieldItem, {
     ref: ref,
     id: id,
@@ -39,7 +51,7 @@ function CurrencyView(_ref, ref) {
     className: style.field
   }, /*#__PURE__*/React.createElement(TextBox, {
     id: id,
-    value: value,
+    value: formattedValue,
     placeholder: placeholder,
     disabled: disabled,
     readonly: readonly,

package/es/library/dot/components/form-fields/currency/frameworks/ui/EventHandlerFactory.js

@@ -13,8 +13,12 @@ class EventHandlersFactory {
   static handleTextBoxFocused(_ref) {
     let {
       state,
+      updateState,
       dispatch
     } = _ref;
+    updateState({ ...state,
+      isFocused: true
+    });
     const {
       name
     } = state.properties;
@@ -30,8 +34,12 @@ class EventHandlersFactory {
   static handleTextBoxBlurred(_ref2) {
     let {
       state,
+      updateState,
       dispatch
     } = _ref2;
+    updateState({ ...state,
+      isFocused: false
+    });
     const {
       name
     } = state.properties;