bromcom-ui 2.8.0-rc.3 → 2.8.0-rc.5

package/dist/cjs/generate-ab5c97d5.js

@@ -0,0 +1,305 @@
+/*!
+ * Built with Stencil
+ * Copyright (c) Bromcom.
+ */
+'use strict';
+
+const colors = require('./colors-43b24668.js');
+
+/**
+ * 'status' prop predefined values
+ */
+exports.StatusProps = void 0;
+(function (StatusProps) {
+  StatusProps["info"] = "info";
+  StatusProps["error"] = "error";
+  StatusProps["warning"] = "warning";
+  StatusProps["success"] = "success";
+  StatusProps["default"] = "default";
+})(exports.StatusProps || (exports.StatusProps = {}));
+/**
+ * 'type' prop predefined values
+ */
+exports.TypeProps = void 0;
+(function (TypeProps) {
+  TypeProps["banner"] = "banner";
+  TypeProps["basic"] = "basic";
+})(exports.TypeProps || (exports.TypeProps = {}));
+
+const version = "2.8.0-rc.5";
+
+function snq(callback, defaultValue) {
+    try {
+        var result = callback();
+        return typeof result === 'undefined' ? defaultValue : result;
+    }
+    catch (err) {
+        if (err instanceof TypeError) {
+            return defaultValue;
+        }
+        throw err;
+    }
+}
+
+const allowedDomains = ["localhost", "beta-regression.bromcomcloud.com", "beta-scrum.bromcomcloud.com", "beta-kanban.bromcomcloud.com"];
+const isAllowedDomain = () => {
+  const hostname = window.location.hostname;
+  return allowedDomains.includes(hostname);
+};
+if (isAllowedDomain()) {
+  console.log(`%cbromcom ui%c version: ${version}-${"p"} `, `color: white; background:#1890FF; font-weight: 300;  font-size:10px;  padding:2px 6px;  border-radius: 5px`, `font-size:10px;`);
+}
+(function checkTheme() {
+  const body = document.querySelector("body");
+  let theme = localStorage.getItem("bcm-theme");
+  if (!body.classList.contains("bcm-theme-*") && theme) {
+    body.classList.add(`bcm-theme-${theme}`);
+  }
+})();
+class Generate {
+  static observeElementRemoval(element, callback) {
+    const observer = new MutationObserver((mutationsList, observer) => {
+      for (const mutation of mutationsList) {
+        if (mutation.type === "childList") {
+          const removedNodes = Array.from(mutation.removedNodes);
+          for (const removedNode of removedNodes) {
+            if (removedNode === element) {
+              callback();
+              observer.disconnect();
+              return;
+            }
+          }
+        }
+      }
+    });
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+  }
+  static getTwColor(color, variable = "--bcm-color-default") {
+    if (!color || !colors.tailwindColor[color]) {
+      return false;
+    }
+    const colorObj = colors.tailwindColor[color];
+    const result = {};
+    for (const [key, value] of Object.entries(colorObj)) {
+      result[`${variable}-${key}`] = value;
+    }
+    return result;
+  }
+}
+Generate.UID = (prefix = "bcm") => `${prefix}${Math.random().toString(36).substr(2, 9)}`;
+Generate.getIconAttrWithStatusType = (status, loading = false) => {
+  if (loading)
+    return { icon: "far fa-spinner-third fa-spin" };
+  switch (status) {
+    case exports.StatusProps.info:
+      return { icon: "far fa-info-circle" };
+    case exports.StatusProps.error:
+      return { icon: "far fa-times-circle" };
+    case exports.StatusProps.warning:
+      return { icon: "far fa-exclamation-circle" };
+    case exports.StatusProps.success:
+      return { icon: "far fa-check-circle" };
+  }
+};
+Generate.createComponent = (el, props, area = "append-area") => {
+  let container = area ? document.querySelector(area) : document.body;
+  if (area && !container) {
+    container = document.createElement("div");
+    container.id = "append-area";
+    document.body.appendChild(container);
+    container.style.visibility = "hidden";
+    container.style.opacity = "0";
+  }
+  let element = document.getElementById(props.id);
+  if (!element) {
+    element = document.createElement(el);
+  }
+  // debugger;
+  Object.keys(props).forEach(key => {
+    element[key] = props[key];
+  });
+  container.appendChild(element);
+  return element;
+};
+Generate.createElement = (tag = "div", props) => {
+  let element = document.getElementById(props.id);
+  if (!element) {
+    element = document.createElement(tag);
+  }
+  Object.keys(props).forEach(key => {
+    if (key == "innerHTML") {
+      element[key] = props[key];
+    }
+    else {
+      element.setAttribute(key, props[key]);
+    }
+  });
+  document.body.appendChild(element);
+  return element;
+};
+Generate.debounceInput = (func, wait, immediate, callBack) => {
+  let timeout;
+  return function () {
+    let context = this, args = arguments;
+    if (callBack)
+      callBack.apply(context, args);
+    let later = function () {
+      timeout = null;
+      if (!immediate)
+        func.apply(context, args);
+    };
+    let callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow)
+      func.apply(context, args);
+  };
+};
+Generate.flatArray = arr => {
+  return arr.reduce((acc, val) => {
+    return acc.concat(Array.isArray(val) ? Generate.flatArray(val) : val);
+  }, []);
+};
+Generate.reverseNodeList = node_list => {
+  let arr = [];
+  for (let i = node_list.length - 1; i >= 0; i--) {
+    arr.push(node_list[i]);
+  }
+  return arr;
+};
+Generate.findEventPathWithKey = (event, key, items) => {
+  items = Array.isArray(items) ? items : [items];
+  let path = event.composedPath() || event.path;
+  if (path) {
+    return path.filter((element) => items.includes(element[key]))[0] !== undefined;
+  }
+};
+Generate.findEventPathHasAttribute = (event, key) => {
+  let path = event.composedPath() || event.path;
+  if (path) {
+    return snq(() => !!path.find((element) => element.hasAttribute(key)), false);
+  }
+};
+Generate.findEventTarget = (event, items) => {
+  items = Array.isArray(items) ? items : [items];
+  let target = event.target || event.srcElement;
+  if (target) {
+    return items.includes(target);
+  }
+};
+Generate.findEventPathWithNodeName = (event, nodeName) => {
+  let path = event.composedPath() || event.path;
+  if (path) {
+    return path.filter((element) => element.nodeName === nodeName)[0];
+  }
+};
+Generate.findEventPath = (event, items) => {
+  items = Array.isArray(items) ? items : [items];
+  let path = event.composedPath() || event.path;
+  if (path) {
+    return path.filter((element) => items.includes(element))[0] !== undefined;
+  }
+};
+Generate.objectIsEmpty = obj => Object.keys(obj).length === 0 && obj.constructor === Object;
+Generate.convertIdsToNestedData = (ids, checklist) => {
+  let result = [];
+  let found = [];
+  checklist.forEach(item => {
+    if (ids && ids.indexOf(item.id.toString()) > -1) {
+      result.push(item);
+    }
+    else {
+      if (item.items) {
+        found = Generate.convertIdsToNestedData(ids, item.items);
+        if (found.length > 0) {
+          item.items = found;
+          result.push(item);
+        }
+      }
+    }
+  });
+  return result;
+};
+//nodelist to array
+Generate.nodeListToArray = nodeList => {
+  return Array.prototype.slice.call(nodeList);
+};
+Generate.setAttributes = (item, obj) => {
+  Object.keys(obj).forEach(key => {
+    item.setAttribute(key, obj[key]);
+  });
+};
+Generate.computedStyle = (element, property) => window.getComputedStyle(element, null).getPropertyValue(property);
+Generate.getAncestor = (el, selector) => {
+  while ((el = el.parentElement) && !el.matches(selector))
+    ;
+  return el;
+};
+Generate.findParentElement = (element, selector) => {
+  const firstChar = selector.charAt(0);
+  function getElementByClass(currentElement, className) {
+    while (currentElement !== null) {
+      if (currentElement.classList.contains(className)) {
+        return currentElement;
+      }
+      currentElement = currentElement.parentElement;
+    }
+    return null;
+  }
+  function getElementById(currentElement, id) {
+    while (currentElement !== null) {
+      if (currentElement.id === id) {
+        return currentElement;
+      }
+      currentElement = currentElement.parentElement;
+    }
+    return null;
+  }
+  function getElementByAttribute(currentElement, attr, value) {
+    while (currentElement !== null) {
+      if (currentElement.hasAttribute(attr) && (value === undefined || currentElement.getAttribute(attr) === value)) {
+        return currentElement;
+      }
+      currentElement = currentElement.parentElement;
+    }
+    return null;
+  }
+  function getElementByTag(currentElement, tag) {
+    while (currentElement !== null) {
+      if (currentElement.tagName.toLowerCase() === tag.toLowerCase()) {
+        return currentElement;
+      }
+      currentElement = currentElement.parentElement;
+    }
+    return null;
+  }
+  if (selector === "*") {
+    // Tüm elementleri seç
+    return element.parentElement;
+  }
+  else if (firstChar === ".") {
+    // Sınıf adı seçicisi
+    const className = selector.slice(1);
+    return getElementByClass(element.parentElement, className);
+  }
+  else if (firstChar === "#") {
+    // ID seçicisi
+    const id = selector.slice(1);
+    return getElementById(element.parentElement, id);
+  }
+  else if (firstChar === "[") {
+    // Öznitelik seçicisi
+    const end = selector.indexOf("]");
+    const attr = selector.slice(1, end);
+    const value = selector.slice(end + 2, -1);
+    return getElementByAttribute(element.parentElement, attr, value);
+  }
+  else {
+    // Etiket adı seçicisi
+    const tag = selector.toLowerCase();
+    return getElementByTag(element.parentElement, tag);
+  }
+};
+
+exports.Generate = Generate;
+exports.snq = snq;

package/dist/cjs/{index-56628fe5.js → index-4506fcd7.js}

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-const index = require('./index-7e2a5376.js');
+const index = require('./index-ddfd6d8f.js');
 
 const appendToMap = (map, propName, value) => {
     const items = map.get(propName);

package/dist/cjs/{index-7e2a5376.js → index-ddfd6d8f.js}

@@ -82,6 +82,18 @@ const isComplexType = (o) => {
     o = typeof o;
     return o === 'object' || o === 'function';
 };
+/**
+ * Helper method for querying a `meta` tag that contains a nonce value
+ * out of a DOM's head.
+ *
+ * @param doc The DOM containing the `head` to query against
+ * @returns The content of the meta tag representing the nonce value, or `undefined` if no tag
+ * exists or the tag has no content.
+ */
+function queryNonceMetaTagContent(doc) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = doc.head) === null || _a === void 0 ? void 0 : _a.querySelector('meta[name="csp-nonce"]')) === null || _b === void 0 ? void 0 : _b.getAttribute('content')) !== null && _c !== void 0 ? _c : undefined;
+}
 /**
  * Production h() function based on Preact by
  * Jason Miller (@developit)
@@ -90,7 +102,6 @@ const isComplexType = (o) => {
  *
  * Modified for Stencil's compiler and vdom
  */
-// const stack: any[] = [];
 // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode;
 // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode;
 const h = (nodeName, vnodeData, ...children) => {
@@ -160,6 +171,14 @@ const h = (nodeName, vnodeData, ...children) => {
     }
     return vnode;
 };
+/**
+ * A utility function for creating a virtual DOM node from a tag and some
+ * possible text content.
+ *
+ * @param tag the tag for this element
+ * @param text possible text content for the node
+ * @returns a newly-minted virtual DOM node
+ */
 const newVNode = (tag, text) => {
     const vnode = {
         $flags$: 0,
@@ -180,11 +199,31 @@ const newVNode = (tag, text) => {
     return vnode;
 };
 const Host = {};
+/**
+ * Check whether a given node is a Host node or not
+ *
+ * @param node the virtual DOM node to check
+ * @returns whether it's a Host node or not
+ */
 const isHost = (node) => node && node.$tag$ === Host;
+/**
+ * Implementation of {@link d.FunctionalUtilities} for Stencil's VDom.
+ *
+ * Note that these functions convert from {@link d.VNode} to
+ * {@link d.ChildNode} to give functional component developers a friendly
+ * interface.
+ */
 const vdomFnUtils = {
     forEach: (children, cb) => children.map(convertToPublic).forEach(cb),
     map: (children, cb) => children.map(convertToPublic).map(cb).map(convertToPrivate),
 };
+/**
+ * Convert a {@link d.VNode} to a {@link d.ChildNode} in order to present a
+ * friendlier public interface (hence, 'convertToPublic').
+ *
+ * @param node the virtual DOM node to convert
+ * @returns a converted child node
+ */
 const convertToPublic = (node) => ({
     vattrs: node.$attrs$,
     vchildren: node.$children$,
@@ -193,6 +232,15 @@ const convertToPublic = (node) => ({
     vtag: node.$tag$,
     vtext: node.$text$,
 });
+/**
+ * Convert a {@link d.ChildNode} back to an equivalent {@link d.VNode} in
+ * order to use the resulting object in the virtual DOM. The initial object was
+ * likely created as part of presenting a public API, so converting it back
+ * involved making it 'private' again (hence, `convertToPrivate`).
+ *
+ * @param node the child node to convert
+ * @returns a converted virtual DOM node
+ */
 const convertToPrivate = (node) => {
     if (typeof node.vtag === 'function') {
         const vnodeData = Object.assign({}, node.vattrs);
@@ -302,6 +350,7 @@ const registerStyle = (scopeId, cssText, allowCS) => {
     styles.set(scopeId, style);
 };
 const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
+    var _a;
     let scopeId = getScopeId(cmpMeta);
     const style = styles.get(scopeId);
     // if an element is NOT connected then getRootNode() will return the wrong root node
@@ -321,6 +370,11 @@ const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {
                         styleElm = doc.createElement('style');
                         styleElm.innerHTML = style;
                     }
+                    // Apply CSP nonce to the style tag if it exists
+                    const nonce = (_a = plt.$nonce$) !== null && _a !== void 0 ? _a : queryNonceMetaTagContent(doc);
+                    if (nonce != null) {
+                        styleElm.setAttribute('nonce', nonce);
+                    }
                     styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));
                 }
                 if (appliedStyles) {
@@ -654,6 +708,21 @@ const putBackInOriginalLocation = (parentElm, recursive) => {
     }
     plt.$flags$ &= ~1 /* PLATFORM_FLAGS.isTmpDisconnected */;
 };
+/**
+ * Create DOM nodes corresponding to a list of {@link d.Vnode} objects and
+ * add them to the DOM in the appropriate place.
+ *
+ * @param parentElm the DOM node which should be used as a parent for the new
+ * DOM nodes
+ * @param before a child of the `parentElm` which the new children should be
+ * inserted before (optional)
+ * @param parentVNode the parent virtual DOM node
+ * @param vnodes the new child virtual DOM nodes to produce DOM nodes for
+ * @param startIdx the index in the child virtual DOM nodes at which to start
+ * creating DOM nodes (inclusive)
+ * @param endIdx the index in the child virtual DOM nodes at which to stop
+ * creating DOM nodes (inclusive)
+ */
 const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {
     let containerElm = ((parentElm['s-cr'] && parentElm['s-cr'].parentNode) || parentElm);
     let childNode;
@@ -670,6 +739,19 @@ const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) =>
         }
     }
 };
+/**
+ * Remove the DOM elements corresponding to a list of {@link d.VNode} objects.
+ * This can be used to, for instance, clean up after a list of children which
+ * should no longer be shown.
+ *
+ * This function also handles some of Stencil's slot relocation logic.
+ *
+ * @param vnodes a list of virtual DOM nodes to remove
+ * @param startIdx the index at which to start removing nodes (inclusive)
+ * @param endIdx the index at which to stop removing nodes (inclusive)
+ * @param vnode a VNode
+ * @param elm an element
+ */
 const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => {
     for (; startIdx <= endIdx; ++startIdx) {
         if ((vnode = vnodes[startIdx])) {
@@ -948,7 +1030,8 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
  *
  * So, in other words, if `key` attrs are not set on VNodes which may be
  * changing order within a `children` array or something along those lines then
- * we could obtain a false positive and then have to do needless re-rendering.
+ * we could obtain a false negative and then have to do needless re-rendering
+ * (i.e. we'd say two VNodes aren't equal when in fact they should be).
  *
  * @param leftVNode the first VNode to check
  * @param rightVNode the second VNode to check
@@ -1176,6 +1259,18 @@ const callNodeRefs = (vNode) => {
         vNode.$children$ && vNode.$children$.map(callNodeRefs);
     }
 };
+/**
+ * The main entry point for Stencil's virtual DOM-based rendering engine
+ *
+ * Given a {@link d.HostRef} container and some virtual DOM nodes, this
+ * function will handle creating a virtual DOM tree with a single root, patching
+ * the current virtual DOM tree onto an old one (if any), dealing with slot
+ * relocation, and reflecting attributes.
+ *
+ * @param hostRef data needed to root and render the virtual DOM tree, such as
+ * the DOM node into which it should be rendered.
+ * @param renderFnResults the virtual DOM nodes to be rendered
+ */
 const renderVdom = (hostRef, renderFnResults) => {
     const hostElm = hostRef.$hostElement$;
     const cmpMeta = hostRef.$cmpMeta$;
@@ -1807,6 +1902,7 @@ const disconnectedCallback = (elm) => {
     }
 };
 const bootstrapLazy = (lazyBundles, options = {}) => {
+    var _a;
     const endBootstrap = createTime();
     const cmpTags = [];
     const exclude = options.exclude || [];
@@ -1889,6 +1985,11 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
     {
         visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS;
         visibilityStyle.setAttribute('data-styles', '');
+        // Apply CSP nonce to the style tag if it exists
+        const nonce = (_a = plt.$nonce$) !== null && _a !== void 0 ? _a : queryNonceMetaTagContent(doc);
+        if (nonce != null) {
+            visibilityStyle.setAttribute('nonce', nonce);
+        }
         head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild);
     }
     // Process deferred connectedCallbacks now all components have been registered
@@ -1940,6 +2041,13 @@ const getHostListenerTarget = (elm, flags) => {
 };
 // prettier-ignore
 const hostListenerOpts = (flags) => (flags & 2 /* LISTENER_FLAGS.Capture */) !== 0;
+/**
+ * Assigns the given value to the nonce property on the runtime platform object.
+ * During runtime, this value is used to set the nonce attribute on all dynamically created script and style tags.
+ * @param nonce The value to be assigned to the platform nonce property.
+ * @returns void
+ */
+const setNonce = (nonce) => (plt.$nonce$ = nonce);
 const hostRefs = /*@__PURE__*/ new WeakMap();
 const getHostRef = (ref) => hostRefs.get(ref);
 const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef);
@@ -2060,3 +2168,4 @@ exports.getRenderingRef = getRenderingRef;
 exports.h = h;
 exports.promiseResolve = promiseResolve;
 exports.registerInstance = registerInstance;
+exports.setNonce = setNonce;

package/dist/cjs/{index-a2b50e51.js → index-fdbf5226.js}

@@ -8,9 +8,9 @@ const _commonjsHelpers = require('./_commonjsHelpers-bd20f4c0.js');
 
 var classnames = _commonjsHelpers.createCommonjsModule(function (module) {
 /*!
-  Copyright (c) 2018 Jed Watson.
-  Licensed under the MIT License (MIT), see
-  http://jedwatson.github.io/classnames
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
 */
 /* global define */
 
@@ -37,14 +37,15 @@ var classnames = _commonjsHelpers.createCommonjsModule(function (module) {
 					}
 				}
 			} else if (argType === 'object') {
-				if (arg.toString === Object.prototype.toString) {
-					for (var key in arg) {
-						if (hasOwn.call(arg, key) && arg[key]) {
-							classes.push(key);
-						}
-					}
-				} else {
+				if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
 					classes.push(arg.toString());
+					continue;
+				}
+
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes.push(key);
+					}
 				}
 			}
 		}

package/dist/cjs/{input-template-98c29bbb.js → input-template-b540fdc4.js}

@@ -4,11 +4,11 @@
  */
 'use strict';
 
-const index$1 = require('./index-7e2a5376.js');
+const index$1 = require('./index-ddfd6d8f.js');
 const types = require('./types-cc4adee7.js');
 const bcm = require('./bcm-634604e3.js');
-const index = require('./index-a2b50e51.js');
-const generate = require('./generate-7b71e00a.js');
+const index = require('./index-fdbf5226.js');
+const generate = require('./generate-ab5c97d5.js');
 
 const InputTemplate = ({ elementType, 
 //textarea

package/dist/cjs/{is-load-decorator-faac117d.js → is-load-decorator-137dded1.js}

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-const index = require('./index-7e2a5376.js');
+const index = require('./index-ddfd6d8f.js');
 
 function IsLoad() {
   return (proto) => {

package/dist/cjs/{json-parse-decarator-79e20ff3.js → json-parse-decarator-fc944651.js}

@@ -4,8 +4,8 @@
  */
 'use strict';
 
-const index = require('./index-7e2a5376.js');
-const generate = require('./generate-7b71e00a.js');
+const index = require('./index-ddfd6d8f.js');
+const generate = require('./generate-ab5c97d5.js');
 
 function JsonParse(attribute, isMethod = false) {
   return (proto, propName) => {

package/dist/cjs/{label-template-098a30a4.js → label-template-cc69bc21.js}

@@ -4,10 +4,10 @@
  */
 'use strict';
 
-const index$1 = require('./index-7e2a5376.js');
-const index = require('./index-a2b50e51.js');
+const index$1 = require('./index-ddfd6d8f.js');
+const index = require('./index-fdbf5226.js');
 const bcm = require('./bcm-634604e3.js');
-const slotTemplate = require('./slot-template-7a07f865.js');
+const slotTemplate = require('./slot-template-3e59d7d8.js');
 
 const LabelTemplate = ({ required, value, size, form, htmlFor, type }) => {
   size = size || "medium";