@zohodesk/library-platform 1.2.0-exp.3 → 1.2.0-exp.45

package/es/bc/sort-by/SortOrderEnum.js

@@ -0,0 +1,8 @@
+var SortOrder = /*#__PURE__*/function (SortOrder) {
+  SortOrder["NONE"] = "none";
+  SortOrder["ASC"] = "ascending";
+  SortOrder["DES"] = "descending";
+  return SortOrder;
+}(SortOrder || {});
+
+export default SortOrder;

package/es/cc/flex-container/Properties.js

@@ -0,0 +1,79 @@
+export default {
+  tagName: {
+    defaultValue: 'div',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    }
+  },
+  className: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    }
+  },
+  isInline: {
+    defaultValue: false,
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'boolean'
+      }
+    }
+  },
+  direction: {
+    defaultValue: 'row',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: ['row', 'column', 'rowReverse', 'columnReverse']
+      }
+    }
+  },
+  alignItems: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: ['start', 'center', 'end', 'baseline', 'stretch']
+      }
+    }
+  },
+  justifyContent: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: ['start', 'center', 'end', 'spaceBetween', 'spaceAround', 'spaceEvenly']
+      }
+    }
+  },
+  alignContent: {
+    defaultValue: '',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: ['start', 'center', 'end', 'spaceBetween', 'spaceAround', 'spaceEvenly']
+      }
+    }
+  },
+  wrap: {
+    defaultValue: 'nowrap',
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: ['wrap', 'nowrap', 'wrapReverse']
+      }
+    }
+  }
+};

package/es/cc/flex-container/Types.js

@@ -0,0 +1,39 @@
+export let Direction = /*#__PURE__*/function (Direction) {
+  Direction["Row"] = "row";
+  Direction["Column"] = "column";
+  Direction["RowReverse"] = "rowReverse";
+  Direction["ColumnReverse"] = "columnReverse";
+  return Direction;
+}({});
+export let AlignItems = /*#__PURE__*/function (AlignItems) {
+  AlignItems["Start"] = "start";
+  AlignItems["Center"] = "center";
+  AlignItems["End"] = "end";
+  AlignItems["Baseline"] = "baseline";
+  AlignItems["Stretch"] = "stretch";
+  return AlignItems;
+}({});
+export let JustifyContent = /*#__PURE__*/function (JustifyContent) {
+  JustifyContent["Start"] = "start";
+  JustifyContent["Center"] = "center";
+  JustifyContent["End"] = "end";
+  JustifyContent["SpaceBetween"] = "spaceBetween";
+  JustifyContent["SpaceAround"] = "spaceAround";
+  JustifyContent["SpaceEvenly"] = "spaceEvenly";
+  return JustifyContent;
+}({});
+export let AlignContent = /*#__PURE__*/function (AlignContent) {
+  AlignContent["Start"] = "start";
+  AlignContent["Center"] = "center";
+  AlignContent["End"] = "end";
+  AlignContent["SpaceBetween"] = "spaceBetween";
+  AlignContent["SpaceAround"] = "spaceAround";
+  AlignContent["Stretch"] = "stretch";
+  return AlignContent;
+}({});
+export let Wrap = /*#__PURE__*/function (Wrap) {
+  Wrap["Wrap"] = "wrap";
+  Wrap["NoWrap"] = "nowrap";
+  Wrap["WrapReverse"] = "wrapReverse";
+  return Wrap;
+}({});

package/es/cc/flex-container/index.js

@@ -0,0 +1,2 @@
+export { default as Properties } from "./Properties";
+export { Properties as PropertiesType, Direction, AlignItems, JustifyContent, AlignContent, Wrap } from "./Types";

package/es/cc/tags/model/TagModel.js

@@ -0,0 +1,26 @@
+function TagModel(_ref) {
+  let {
+    id,
+    label,
+    color,
+    imageSrc,
+    imageAltText,
+    iconName,
+    disabled,
+    size,
+    tooltip
+  } = _ref;
+  return {
+    id,
+    label,
+    color,
+    imageSrc,
+    imageAltText,
+    iconName,
+    disabled,
+    size,
+    tooltip
+  };
+}
+
+export default TagModel;

package/es/library/behaviours/sort-by/adapters/controllers/SortBy.js

@@ -0,0 +1,28 @@
+import AbstractController from "./AbstractController";
+
+class SortByController extends AbstractController {
+  handle(event) {
+    const {
+      sortByUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    let {
+      id,
+      name
+    } = action.payload;
+    sortByUseCase.updateDependencies(state, updateState);
+    sortByUseCase.execute({
+      id,
+      name,
+      dispatch
+    });
+  }
+
+}
+
+export default SortByController;

package/es/library/behaviours/sort-by/applications/interfaces/output/SortByOutputModel.js

@@ -0,0 +1 @@
+export {};

package/es/library/behaviours/sort-by/applications/usecases/SortBy.js

@@ -0,0 +1,28 @@
+import { SORTBY_SORTED } from "../../../../../bc/sort-by/Constants";
+import AbstractUseCase from "./AbstractUseCase";
+
+class SortBy extends AbstractUseCase {
+  execute(input) {
+    const {
+      id,
+      name,
+      dispatch
+    } = input;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const sortBy = repository.getSortByEntity();
+    sortBy.doSorting(id, name);
+    presenter.updateSortBy(sortBy.toObject());
+    dispatch({
+      type: SORTBY_SORTED,
+      payload: {
+        sortBy: sortBy.toObject()
+      }
+    });
+  }
+
+}
+
+export default SortBy;

package/es/library/behaviours/sort-by/frameworks/ui/DemoBehaviour.js

@@ -0,0 +1,20 @@
+import Properties from "../../../../../bc/sort-by/Properties";
+
+// REVIEW: Class never used
+class DemoBehaviour {
+  static create() {
+    return {
+      name: 'demo_behaviour',
+      setInitialState: () => ({}),
+      properties: Properties,
+      eventHandlers: {
+        "DEMO": () => {
+          alert('demo');
+        }
+      }
+    };
+  }
+
+}
+
+export default DemoBehaviour;

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

@@ -0,0 +1,84 @@
+import { ErrorCodes } from "../../../../cc/component/ErrorStructure";
+
+/**
+ * SlotValidator validates slot component types against allowedComponentTypes restrictions.
+ * Supports wildcard '*' to allow all component types.
+ * Non-breaking validation - errors don't disrupt component flow.
+ */
+export default class SlotValidator {
+  /**
+   * Validates that all components in slots respect the allowedComponentTypes restrictions
+   * @param slots - Array of slot definitions with component type restrictions
+   * @returns SlotValidationResult with validation status and errors
+   */
+  static validateSlots() {
+    let slots = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    const errors = [];
+    slots.forEach(slot => {
+      const {
+        name: slotName,
+        elements = [],
+        allowedComponentTypes = ['*']
+      } = slot; // If allowedComponentTypes contains '*', all components are allowed
+
+      const allowAllComponents = allowedComponentTypes.includes('*');
+      elements.forEach(element => {
+        const {
+          type: componentType,
+          name: elementName
+        } = element; // Skip validation if wildcard is specified
+
+        if (!allowAllComponents && !allowedComponentTypes.includes(componentType)) {
+          errors.push({
+            message: `Component type '${componentType}' is not allowed in slot '${slotName}'. Allowed types: ${allowedComponentTypes.join(', ')}`,
+            slotName,
+            elementName,
+            componentType
+          });
+        }
+      });
+    });
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Throws a structured error if slot validation fails
+   * Error is non-breaking to allow other components to continue rendering
+   * @param slots - Array of slot definitions
+   * @throws ErrorStructure with non-breaking error flag
+   */
+
+
+  static validateAndThrowIfInvalid() {
+    let slots = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    const validationResult = SlotValidator.validateSlots(slots);
+
+    if (!validationResult.isValid) {
+      // Non-breaking error - component continues to render
+      const error = {
+        code: ErrorCodes.PROPERTY_VALIDATION_FAILED,
+        message: 'Slot component type validation failed',
+        errorDetails: {
+          isBreaking: false,
+          // Important: allows other components to continue
+          slotValidationErrors: validationResult.errors
+        }
+      };
+      throw error;
+    }
+  }
+  /**
+   * Returns true if wildcard is defined, allowing all component types
+   * @param allowedComponentTypes - Array of allowed component types
+   * @returns boolean
+   */
+
+
+  static hasWildcardPermission() {
+    let allowedComponentTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return allowedComponentTypes.includes('*') || allowedComponentTypes.length === 0;
+  }
+
+}

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

@@ -0,0 +1,56 @@
+import React, { useState, useRef, useEffect, forwardRef } from 'react';
+import DependencyFactory from "./DependencyFactory";
+/* eslint-disable */
+
+function Component(props) {
+  const [state, setState] = useState(null);
+  const elementRef = useRef(null);
+  const {
+    controller,
+    presenter,
+    eventManager
+  } = DependencyFactory.create({
+    updateState: newState => {
+      // Hack initial render
+      if (state == null) {
+        setState(newState);
+      } else {
+        setState(() => newState);
+      }
+    }
+  });
+  const helpers = {
+    updateState: controller.updateState.bind(controller),
+    updateProperties: controller.updateProperties.bind(controller),
+    dispatch: controller.dispatch.bind(controller)
+  };
+  useEffect(() => {
+    controller.initialize({ ...input,
+      newProps: props,
+      helpers
+    });
+    eventManager.name = input.name;
+    controller.mount();
+    return () => {
+      controller.unmount();
+    };
+  }, []);
+  useEffect(() => {
+    controller.updateProperties(props);
+  }, [props]);
+  const View = /*#__PURE__*/forwardRef(input.View);
+
+  if (state?.error) {
+    console.log(state.error);
+    return /*#__PURE__*/React.createElement("div", null, "error");
+  } else {
+    return /*#__PURE__*/React.createElement(View, {
+      ref: eventManager.setElement.bind(eventManager),
+      helpers: helpers,
+      state: state
+    });
+  }
+}
+
+;
+export default Component;