@nocobase/utils 0.9.2-alpha.3 → 0.9.3-alpha.1

package/lib/client.d.ts

@@ -8,3 +8,4 @@ export * from './number';
 export * from './parse-filter';
 export * from './registry';
 export * from './uid';
+export * from './json-templates';

package/lib/client.js

@@ -112,4 +112,15 @@ Object.keys(_uid).forEach(function (key) {
       return _uid[key];
     }
   });
+});
+var _jsonTemplates = require("./json-templates");
+Object.keys(_jsonTemplates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _jsonTemplates[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _jsonTemplates[key];
+    }
+  });
 });

package/lib/index.d.ts

@@ -13,3 +13,4 @@ export * from './registry';
 export * from './requireModule';
 export * from './toposort';
 export * from './uid';
+export * from './json-templates';

package/lib/index.js

@@ -167,4 +167,15 @@ Object.keys(_uid).forEach(function (key) {
       return _uid[key];
     }
   });
+});
+var _jsonTemplates = require("./json-templates");
+Object.keys(_jsonTemplates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _jsonTemplates[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _jsonTemplates[key];
+    }
+  });
 });

package/lib/json-templates.d.ts

@@ -0,0 +1 @@
+export declare function parse(value: any): any;

package/lib/json-templates.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parse = parse;
+function _objectPath() {
+  const data = _interopRequireDefault(require("object-path"));
+  _objectPath = function _objectPath() {
+    return data;
+  };
+  return data;
+}
+function _dedupe() {
+  const data = _interopRequireDefault(require("dedupe"));
+  _dedupe = function _dedupe() {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// json-templates
+// Simple templating within JSON structures.
+//
+// Created by Curran Kelleher and Chrostophe Serafin.
+// Contributions from Paul Brewer and Javier Blanco Martinez.
+
+// An enhanced version of `typeof` that handles arrays and dates as well.
+function type(value) {
+  let valueType = typeof value;
+  if (Array.isArray(value)) {
+    valueType = 'array';
+  } else if (value instanceof Date) {
+    valueType = 'date';
+  } else if (value === null) {
+    valueType = 'null';
+  }
+  return valueType;
+}
+// Constructs a parameter object from a match result.
+// e.g. "['{{foo}}']" --> { key: "foo" }
+// e.g. "['{{foo:bar}}']" --> { key: "foo", defaultValue: "bar" }
+function Parameter(match) {
+  let param;
+  const matchValue = match.substr(2, match.length - 4).trim();
+  const i = matchValue.indexOf(':');
+  if (i !== -1) {
+    param = {
+      key: matchValue.substr(0, i),
+      defaultValue: matchValue.substr(i + 1)
+    };
+  } else {
+    param = {
+      key: matchValue
+    };
+  }
+  return param;
+}
+// Constructs a template function with deduped `parameters` property.
+function Template(fn, parameters) {
+  // Paul Brewer Dec 2017 add deduplication call, use only key property to eliminate
+  Object.assign(fn, {
+    parameters: (0, _dedupe().default)(parameters, item => item.key)
+  });
+  return fn;
+}
+// Parses the given template object.
+//
+// Returns a function `template(context)` that will "fill in" the template
+// with the context object passed to it.
+//
+// The returned function has a `parameters` property,
+// which is an array of parameter descriptor objects,
+// each of which has a `key` property and possibly a `defaultValue` property.
+function parse(value) {
+  switch (type(value)) {
+    case 'string':
+      return parseString(value);
+    case 'object':
+      return parseObject(value);
+    case 'array':
+      return parseArray(value);
+    default:
+      return Template(function () {
+        return value;
+      }, []);
+  }
+}
+// Parses leaf nodes of the template object that are strings.
+// Also used for parsing keys that contain templates.
+const parseString = (() => {
+  // This regular expression detects instances of the
+  // template parameter syntax such as {{foo}} or {{foo:someDefault}}.
+  const regex = /{{(\w|:|[\s-+.,@///()?=*_$])+}}/g;
+  return str => {
+    let parameters = [];
+    let templateFn = context => str;
+    const matches = str.match(regex);
+    if (matches) {
+      parameters = matches.map(Parameter);
+      templateFn = context => {
+        context = context || {};
+        return matches.reduce((result, match, i) => {
+          const parameter = parameters[i];
+          let value = _objectPath().default.get(context, parameter.key);
+          if (value == null) {
+            value = parameter.defaultValue;
+          }
+          if (typeof value === 'function') {
+            value = value();
+          }
+          if (typeof value === 'object') {
+            return value;
+          }
+          // Accommodate numbers as values.
+          if (matches.length === 1 && str.startsWith('{{') && str.endsWith('}}')) {
+            return value;
+          }
+          return result.replace(match, value == null ? '' : value);
+        }, str);
+      };
+    }
+    return Template(templateFn, parameters);
+  };
+})();
+// Parses non-leaf-nodes in the template object that are objects.
+function parseObject(object) {
+  const children = Object.keys(object).map(key => ({
+    keyTemplate: parseString(key),
+    valueTemplate: parse(object[key])
+  }));
+  const templateParameters = children.reduce((parameters, child) => parameters.concat(child.valueTemplate.parameters, child.keyTemplate.parameters), []);
+  const templateFn = context => {
+    return children.reduce((newObject, child) => {
+      newObject[child.keyTemplate(context)] = child.valueTemplate(context);
+      return newObject;
+    }, {});
+  };
+  return Template(templateFn, templateParameters);
+}
+// Parses non-leaf-nodes in the template object that are arrays.
+function parseArray(array) {
+  const templates = array.map(parse);
+  const templateParameters = templates.reduce((parameters, template) => parameters.concat(template.parameters), []);
+  const templateFn = context => templates.map(template => template(context));
+  return Template(templateFn, templateParameters);
+}

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@nocobase/utils",
-  "version": "0.9.2-alpha.3",
+  "version": "0.9.3-alpha.1",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
     "@hapi/topo": "^6.0.0",
+    "dedupe": "^3.0.2",
     "deepmerge": "^4.2.2",
     "flat-to-nested": "^1.1.1",
-    "graphlib": "^2.1.8"
+    "graphlib": "^2.1.8",
+    "object-path": "^0.11.8"
   },
   "peerDependencies": {
     "moment": "2.x",
     "rc-input-number": "7.x"
   },
-  "gitHead": "b6b5f9372202d942c97d2d90a4197e060db05124"
+  "gitHead": "24979bc561537c0b84469c161eeef1a6de4c4684"
 }