@next-core/brick-utils 2.48.1 → 2.50.0

package/dist/index.bundle.js

@@ -1,16 +1,18 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@babel/runtime/helpers/taggedTemplateLiteral'), require('@next-core/pipes'), require('js-yaml')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/objectWithoutProperties', '@babel/runtime/helpers/taggedTemplateLiteral', '@next-core/pipes', 'js-yaml'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._objectWithoutProperties, global._taggedTemplateLiteral, global.pipes, global.yaml));
-})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _objectWithoutProperties, _taggedTemplateLiteral, pipes, yaml) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@babel/runtime/helpers/taggedTemplateLiteral'), require('@next-core/pipes'), require('moment'), require('js-yaml')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/objectWithoutProperties', '@babel/runtime/helpers/taggedTemplateLiteral', '@next-core/pipes', 'moment', 'js-yaml'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._objectWithoutProperties, global._taggedTemplateLiteral, global.pipes, global.moment, global.yaml));
+})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _objectWithoutProperties, _taggedTemplateLiteral, pipes, moment, yaml) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
+  var lodash__default = /*#__PURE__*/_interopDefaultLegacy(lodash);
   var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
   var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
   var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
   var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefaultLegacy(_taggedTemplateLiteral);
+  var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
   var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
 
   var cache$1 = new Map();
@@ -17482,7 +17484,7 @@
   // `raw` should always be asserted by `isEvaluable`.
   function preevaluate(raw, options) {
     var fixes = [];
-    var source = raw.replace(/^\s*<%[~=]?\s|\s%>\s*$/g, m => {
+    var source = raw.replace(/^\s*<%[~=!]?\s|\s%>\s*$/g, m => {
       fixes.push(m);
       return "";
     });
@@ -17504,6 +17506,9 @@
   function shouldAllowRecursiveEvaluations(raw) {
     return /^\s*<%~\s/.test(raw);
   }
+  function isSnippetEvaluation(raw) {
+    return /^\s*<%[!@]\s/.test(raw) && /\s%>\s*$/.test(raw);
+  }
   function isTrackAll(raw) {
     return /^\s*<%=\s/.test(raw) && /\s%>\s*$/.test(raw);
   }
@@ -17558,13 +17563,14 @@
     var {
       matchExpressionString,
       visitNonExpressionString,
-      visitObject
+      visitObject,
+      customIsEvaluable = isEvaluable
     } = typeof options === "string" ? {
       matchExpressionString: v => v.includes(options)
     } : options;
     function visit(value) {
       if (typeof value === "string") {
-        if (matchExpressionString(value) && isEvaluable(value)) {
+        if (matchExpressionString(value) && customIsEvaluable(value)) {
           try {
             preevaluate(value, {
               withParent: true,
@@ -20404,6 +20410,211 @@
     return node.type === "LogicalExpression" ? node.operator === (expect ? "||" : "&&") && [node.left, node.right].some(item => isConstantLogical(item, expect, options)) : node.type === "UnaryExpression" ? node.operator === "!" && isConstantLogical(node.argument, !expect, options) : node.type === "Literal" ? !!node.value === expect : node.type === "Identifier" ? node.name === "undefined" ? !expect : false : constantFeatureFlags && node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "FLAGS" && (node.computed ? node.property.type === "Literal" && typeof node.property.value === "string" && !!featureFlags[node.property.value] === expect : node.property.type === "Identifier" && !!featureFlags[node.property.name] === expect);
   }
 
+  function supply(attemptToVisitGlobals, providedGlobalVariables, mock) {
+    var globalVariables = _objectSpread__default["default"]({}, providedGlobalVariables);
+    // Allow limited browser builtin values.
+    globalVariables["undefined"] = undefined;
+    for (var variableName of attemptToVisitGlobals) {
+      if (!Object.prototype.hasOwnProperty.call(globalVariables, variableName)) {
+        var variable = supplyIndividual(variableName, mock);
+        if (variable !== undefined) {
+          globalVariables[variableName] = variable;
+        }
+      }
+    }
+    return globalVariables;
+  }
+  var shouldOmitInLodash = new Set([
+  // Omit all mutable methods from lodash.
+  // But allow sequence methods like `_.chain`.
+  "fill", "pull", "pullAll", "pullAllBy", "pullAllWith", "pullAt", "remove", "reverse", "assign", "assignIn", "assignInWith", "assignWith", "defaults", "defaultsDeep", "merge", "mergeWith", "set", "setWith", "unset", "update", "updateWith",
+  /**
+   * Ignore `Function` methods from lodash, too.
+   * There are chances to invoke `Object.assign`, etc.
+   *
+   * E.g.:
+   *
+   * ```
+   * _.wrap(_.method('constructor.assign',{b:2},{b:3}),(func,...a) => func(...a))({})
+   * ```
+   */
+  "after", "ary", "before", "bind", "bindKey", "curry", "curryRight", "debounce", "defer", "delay", "flip", "memoize", "negate", "once", "overArgs", "partial", "partialRight", "rearg", "rest", "spread", "throttle", "unary", "wrap"]);
+
+  // Omit all mutable methods from moment.
+  var shouldOmitInMoment = new Set(["lang", "langData", "locale", "localeData", "defineLocale", "updateLocale", "updateOffset"]);
+  var allowedGlobalObjects = new Set(["Array", "Boolean", "Date", "Infinity", "JSON", "Math", "NaN", "Number", "String", "RegExp", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "isFinite", "isNaN", "parseFloat", "parseInt", "Map", "Set", "URLSearchParams", "WeakMap", "WeakSet", "atob", "btoa"]);
+  function supplyIndividual(variableName, mock) {
+    switch (variableName) {
+      case "Object":
+        // Do not allow mutable methods like `Object.assign`.
+        return delegateMethods(Object, ["entries", "fromEntries", "keys", "values"]);
+      case "_":
+        return Object.fromEntries(Object.entries(lodash__default["default"]).filter(entry => !shouldOmitInLodash.has(entry[0])).concat(mock ? [["uniqueId", prefix => "".concat(prefix !== null && prefix !== void 0 ? prefix : "", "42")]] : []));
+      case "moment":
+        return Object.assign(function () {
+          return moment__default["default"](...arguments);
+        }, Object.fromEntries(Object.entries(moment__default["default"]).filter(entry => !shouldOmitInMoment.has(entry[0]))));
+      case "PIPES":
+        return pipes.pipes;
+      case "TAG_URL":
+        return tagUrlFactory(true);
+      case "SAFE_TAG_URL":
+        return tagUrlFactory();
+      default:
+        if (allowedGlobalObjects.has(variableName)) {
+          return window[variableName];
+        }
+    }
+  }
+  function delegateMethods(target, methods) {
+    return Object.fromEntries(methods.map(method => [method, function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return target[method].apply(target, args);
+    }]));
+  }
+  /**
+   * Pass `ignoreSlashes` as `true` to encode all tagged expressions
+   * as URL components, except for `/` which maybe used in `APP.homepage`.
+   *
+   * Otherwise encode all tagged expressions as URL components.
+   * This will encode `/` as `%2F`. So do not use it directly
+   * with `APP.homepage` as in template expressions.
+   *
+   * @example
+   *
+   * ```js
+   * TAG_URL`${APP.homepage}/list?q=${q}&redirect=${redirect}`
+   * ```
+   *
+   * ```js
+   * SAFE_TAG_URL`file/${path}?q=${q}`
+   * // `path` will be fully transformed by `encodeURIComponent`.
+   * ```
+   *
+   * ```js
+   * // Wrap `APP.homepage` outside of `SAFE_TAG_URL`.
+   * `${APP.homepage}/${SAFE_TAG_URL`file/${path}?q=${q}`}`
+   * ```
+   */
+  function tagUrlFactory(ignoreSlashes) {
+    return function (strings) {
+      for (var _len2 = arguments.length, partials = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        partials[_key2 - 1] = arguments[_key2];
+      }
+      var result = [];
+      strings.forEach((str, index) => {
+        result.push(str);
+        if (index < partials.length) {
+          result.push(ignoreSlashes ? String(partials[index]).replace(/[^/]+/g, p => encodeURIComponent(p)) : encodeURIComponent(String(partials[index])));
+        }
+      });
+      return result.join("");
+    };
+  }
+
+  function beforeVisitSnippetParamsFactory(collection) {
+    return function beforeVisitParams(node, parent) {
+      if (node.name === "SNIPPET_PARAMS") {
+        var memberParent = parent[parent.length - 1];
+        if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+          if (!memberParent.node.computed && memberParent.node.property.type === "Identifier") {
+            collection.add(memberParent.node.property.name);
+          } else if (memberParent.node.computed && memberParent.node.property.type === "Literal") {
+            collection.add(memberParent.node.property.value);
+          }
+        }
+      }
+    };
+  }
+  function checkParamsValid(nameList, context) {
+    var {
+      declareParams = {},
+      inputParams = {}
+    } = context;
+    return nameList.forEach(name => {
+      var _declareParams$name;
+      var type = (_declareParams$name = declareParams[name]) === null || _declareParams$name === void 0 ? void 0 : _declareParams$name.type;
+      if (!type) {
+        throw new Error("Missing type of ".concat(name, " in snippet params"));
+      }
+      var valid = ["string", "number", "boolean"].includes(type);
+      if (!valid) {
+        throw new Error("The ".concat(type, " type is not supported of ").concat(name, " in snippet params"));
+      }
+      var actualType = inputParams[name];
+      if (actualType !== undefined && typeof actualType !== type) {
+        throw new Error("The ".concat(name, " is declared as type ").concat(type, ", but it is receiving a value of type ").concat(typeof actualType));
+      }
+    });
+  }
+  function scanSnippetInStoryboard(data) {
+    var collection = new Set();
+    var beforeVisitGlobal = beforeVisitSnippetParamsFactory(collection);
+    visitStoryboardExpressions(data, beforeVisitGlobal, {
+      matchExpressionString: v => v.includes("SNIPPET_PARAMS"),
+      customIsEvaluable: isSnippetEvaluation
+    });
+    return Array.from(collection);
+  }
+  function computeRealSnippetConf(value, context) {
+    if (typeof value === "string" && isSnippetEvaluation(value)) {
+      try {
+        var raw = value;
+        var ctxOrState = context.rootType === "template" ? "STATE" : "CTX";
+        if (/^\s*<%@\s/.test(value)) {
+          var replacements = [{
+            search: "<%@",
+            replace: "<%"
+          }, {
+            search: /\bCTX_OR_STATE\b/g,
+            replace: ctxOrState
+          }];
+          var _result = value;
+          replacements.forEach(replacement => {
+            _result = _result.replace(replacement.search, replacement.replace);
+          });
+          return _result;
+        }
+        var globalVariables = {};
+        var {
+          expression,
+          attemptToVisitGlobals,
+          source
+        } = preevaluate(raw);
+        var attemptVisitSnippetParams = attemptToVisitGlobals.has("SNIPPET_PARAMS");
+        if (attemptVisitSnippetParams) {
+          globalVariables.SNIPPET_PARAMS = context.inputParams;
+        }
+        var result = cook(expression, source, {
+          globalVariables: supply(attemptToVisitGlobals, globalVariables)
+        });
+        return result;
+      } catch (error) {
+        /* istanbul ignore next */
+        // eslint-disable-next-line no-console
+        console.error("Parse storyboard expression failed:", error);
+      }
+    }
+    if (!isObject$1(value)) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map(v => computeRealSnippetConf(v, context));
+    }
+    return Object.fromEntries(Object.entries(value).map(_ref => {
+      var [k, v] = _ref;
+      return [computeRealSnippetConf(k, context), computeRealSnippetConf(v, context)];
+    }));
+  }
+  function snippetEvaluate(brickConf, context) {
+    var collection = scanSnippetInStoryboard(brickConf);
+    checkParamsValid(collection, context);
+    var result = computeRealSnippetConf(brickConf, context);
+    return result;
+  }
+
   Object.defineProperty(exports, 'pipes', {
     enumerable: true,
     get: function () { return pipes.pipes; }
@@ -20437,6 +20648,7 @@
   exports.isEvaluable = isEvaluable;
   exports.isObject = isObject$1;
   exports.isRouteNode = isRouteNode;
+  exports.isSnippetEvaluation = isSnippetEvaluation;
   exports.isSnippetNode = isSnippetNode;
   exports.isTrackAll = isTrackAll;
   exports.lint = lint;
@@ -20479,6 +20691,7 @@
   exports.scanTemplatesInStoryboard = scanTemplatesInStoryboard;
   exports.shouldAllowRecursiveEvaluations = shouldAllowRecursiveEvaluations;
   exports.smartDisplayForEvaluableString = smartDisplayForEvaluableString;
+  exports.snippetEvaluate = snippetEvaluate;
   exports.syncResolveContextConcurrently = syncResolveContextConcurrently;
   exports.toPath = toPath;
   exports.tokTypes = tokTypes_1;