@nocobase/utils 0.9.1-alpha.2 → 0.9.2-alpha.1

package/lib/assign.d.ts

@@ -4,7 +4,6 @@ export declare type MergeStrategy = MergeStrategyType | MergeStrategyFunc;
 export interface MergeStrategies {
     [key: string]: MergeStrategy;
 }
-export default function isPlainObject(value: any): boolean;
 export declare const mergeStrategies: Map<MergeStrategyType, MergeStrategyFunc>;
 export declare function assign(target: any, source: any, strategies?: MergeStrategies): any;
 export {};

package/lib/assign.js

@@ -4,70 +4,47 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assign = assign;
-exports.default = isPlainObject;
 exports.mergeStrategies = void 0;
-
 function _deepmerge() {
   const data = _interopRequireDefault(require("deepmerge"));
-
   _deepmerge = function _deepmerge() {
     return data;
   };
-
   return data;
 }
-
 function _lodash() {
   const data = _interopRequireDefault(require("lodash"));
-
   _lodash = function _lodash() {
     return data;
   };
-
   return data;
 }
-
+var _common = require("./common");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function isPlainObject(value) {
-  if (Object.prototype.toString.call(value) !== '[object Object]') {
-    return false;
-  }
-
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === null || prototype === Object.prototype;
-}
-
 function getEnumerableOwnPropertySymbols(target) {
   return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(symbol => target.propertyIsEnumerable(symbol)) : [];
 }
-
 function getKeys(target) {
   return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
 }
-
 const mergeStrategies = new Map();
 exports.mergeStrategies = mergeStrategies;
 mergeStrategies.set('overwrite', (_, y) => {
   if (typeof y === 'string') {
     y = y.split(',');
   }
-
   return y;
 });
 mergeStrategies.set('andMerge', (x, y) => {
   if (!x && !y) {
     return;
   }
-
   if (!x) {
     return y;
   }
-
   if (!y) {
     return x;
   }
-
   return {
     $and: [x, y]
   };
@@ -76,69 +53,57 @@ mergeStrategies.set('orMerge', (x, y) => {
   if (!x && !y) {
     return;
   }
-
   if (!x) {
     return y;
   }
-
   if (!y) {
     return x;
   }
-
   return {
     $or: [x, y]
   };
 });
 mergeStrategies.set('deepMerge', (x, y) => {
-  return isPlainObject(x) && isPlainObject(y) ? (0, _deepmerge().default)(x, y, {
+  return (0, _common.isPlainObject)(x) && (0, _common.isPlainObject)(y) ? (0, _deepmerge().default)(x, y, {
     arrayMerge: (x, y) => y
   }) : y;
 });
 mergeStrategies.set('merge', (x, y) => {
-  return isPlainObject(x) && isPlainObject(y) ? Object.assign(x, y) : y;
+  return (0, _common.isPlainObject)(x) && (0, _common.isPlainObject)(y) ? Object.assign(x, y) : y;
 });
 mergeStrategies.set('union', (x, y) => {
   if (typeof x === 'string') {
     x = x.split(',');
   }
-
   if (typeof y === 'string') {
     y = y.split(',');
   }
-
   return _lodash().default.uniq((x || []).concat(y || [])).filter(Boolean);
 });
 mergeStrategies.set('intersect', (x, y) => (() => {
   if (typeof x === 'string') {
     x = x.split(',');
   }
-
   if (typeof y === 'string') {
     y = y.split(',');
   }
-
   if (!Array.isArray(x) || x.length === 0) {
     return y || [];
   }
-
   if (!Array.isArray(y) || y.length === 0) {
     return x || [];
   }
-
   return x.filter(v => y.includes(v));
 })().filter(Boolean));
-
 function assign(target, source, strategies = {}) {
   getKeys(source).forEach(sourceKey => {
     const strategy = strategies[sourceKey];
     let func = mergeStrategies.get('deepMerge');
-
     if (typeof strategy === 'function') {
       func = strategy;
     } else if (typeof strategy === 'string' && mergeStrategies.has(strategy)) {
       func = mergeStrategies.get(strategy);
     }
-
     target[sourceKey] = func(target[sourceKey], source[sourceKey]);
   });
   return target;

package/lib/client.d.ts

@@ -1,5 +1,9 @@
+export * from './collections-graph';
+export * from './common';
 export * from './date';
+export * from './forEach';
 export * from './merge';
 export * from './number';
+export * from './parse-filter';
 export * from './registry';
 export * from './uid';

package/lib/client.js

@@ -3,9 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
+var _collectionsGraph = require("./collections-graph");
+Object.keys(_collectionsGraph).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _collectionsGraph[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _collectionsGraph[key];
+    }
+  });
+});
+var _common = require("./common");
+Object.keys(_common).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _common[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _common[key];
+    }
+  });
+});
 var _date = require("./date");
-
 Object.keys(_date).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _date[key]) return;
@@ -16,9 +36,18 @@ Object.keys(_date).forEach(function (key) {
     }
   });
 });
-
+var _forEach = require("./forEach");
+Object.keys(_forEach).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _forEach[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _forEach[key];
+    }
+  });
+});
 var _merge = require("./merge");
-
 Object.keys(_merge).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _merge[key]) return;
@@ -29,9 +58,7 @@ Object.keys(_merge).forEach(function (key) {
     }
   });
 });
-
 var _number = require("./number");
-
 Object.keys(_number).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _number[key]) return;
@@ -42,9 +69,18 @@ Object.keys(_number).forEach(function (key) {
     }
   });
 });
-
+var _parseFilter = require("./parse-filter");
+Object.keys(_parseFilter).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseFilter[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _parseFilter[key];
+    }
+  });
+});
 var _registry = require("./registry");
-
 Object.keys(_registry).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _registry[key]) return;
@@ -55,9 +91,7 @@ Object.keys(_registry).forEach(function (key) {
     }
   });
 });
-
 var _uid = require("./uid");
-
 Object.keys(_uid).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _uid[key]) return;

package/lib/collections-graph.d.ts

@@ -0,0 +1,16 @@
+declare type BuildGraphOptions = {
+    direction?: 'forward' | 'reverse';
+    collections: any[];
+};
+export declare class CollectionsGraph {
+    static graphlib(): any;
+    static connectedNodes(options: BuildGraphOptions & {
+        nodes: Array<string>;
+        excludes?: Array<string>;
+    }): unknown[];
+    static preOrder(options: BuildGraphOptions & {
+        node: string;
+    }): any;
+    static build(options: BuildGraphOptions): any;
+}
+export {};

package/lib/collections-graph.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CollectionsGraph = void 0;
+function graphlib() {
+  const data = _interopRequireWildcard(require("graphlib"));
+  graphlib = function graphlib() {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function _lodash() {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+class CollectionsGraph {
+  static graphlib() {
+    return graphlib();
+  }
+  static connectedNodes(options) {
+    const nodes = (0, _lodash().castArray)(options.nodes);
+    const excludes = (0, _lodash().castArray)(options.excludes || []);
+    const graph = CollectionsGraph.build(options);
+    const connectedNodes = new Set();
+    var _iterator = _createForOfIteratorHelper(nodes),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const node = _step.value;
+        const connected = graphlib().alg.preorder(graph, node);
+        var _iterator2 = _createForOfIteratorHelper(connected),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            const connectedNode = _step2.value;
+            if (excludes.includes(connectedNode)) continue;
+            connectedNodes.add(connectedNode);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return Array.from(connectedNodes);
+  }
+  static preOrder(options) {
+    return CollectionsGraph.graphlib().alg.preorder(CollectionsGraph.build(options), options.node);
+  }
+  static build(options) {
+    const collections = options.collections;
+    const direction = (options === null || options === void 0 ? void 0 : options.direction) || 'forward';
+    const isForward = direction === 'forward';
+    const graph = new (graphlib().Graph)();
+    var _iterator3 = _createForOfIteratorHelper(collections),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        const collection = _step3.value;
+        graph.setNode(collection.name);
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    var _iterator4 = _createForOfIteratorHelper(collections),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        const collection = _step4.value;
+        const parents = collection.inherits || [];
+        var _iterator5 = _createForOfIteratorHelper(parents),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            const parent = _step5.value;
+            if (isForward) {
+              graph.setEdge(collection.name, parent);
+            } else {
+              graph.setEdge(parent, collection.name);
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        var _iterator6 = _createForOfIteratorHelper(collection.fields || []),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            const field = _step6.value;
+            if (field.type === 'hasMany' || field.type === 'belongsTo' || field.type === 'hasOne') {
+              isForward ? graph.setEdge(collection.name, field.target) : graph.setEdge(field.target, collection.name);
+            }
+            if (field.type === 'belongsToMany') {
+              const throughCollection = field.through;
+              if (isForward) {
+                graph.setEdge(collection.name, throughCollection);
+                graph.setEdge(throughCollection, field.target);
+              } else {
+                graph.setEdge(field.target, throughCollection);
+                graph.setEdge(throughCollection, collection.name);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return graph;
+  }
+}
+exports.CollectionsGraph = CollectionsGraph;

package/lib/common.d.ts

@@ -0,0 +1,5 @@
+export declare const isString: (value: any) => value is string;
+export declare const isArray: (value: any) => value is any[];
+export declare const isEmpty: (value: unknown) => boolean;
+export declare const isPlainObject: (value: any) => boolean;
+export declare const hasEmptyValue: (objOrArr: object | any[]) => any;

package/lib/common.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isString = exports.isPlainObject = exports.isEmpty = exports.isArray = exports.hasEmptyValue = void 0;
+const isString = value => {
+  return typeof value === 'string';
+};
+exports.isString = isString;
+const isArray = value => {
+  return Array.isArray(value);
+};
+exports.isArray = isArray;
+const isEmpty = value => {
+  if (isPlainObject(value)) {
+    return Object.keys(value).length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return !value;
+};
+exports.isEmpty = isEmpty;
+const isPlainObject = value => {
+  if (Object.prototype.toString.call(value) !== '[object Object]') {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+};
+exports.isPlainObject = isPlainObject;
+const hasEmptyValue = objOrArr => {
+  let result = true;
+  for (const key in objOrArr) {
+    result = false;
+    if (isArray(objOrArr[key]) && objOrArr[key].length === 0) {
+      return true;
+    }
+    if (!objOrArr[key]) {
+      return true;
+    }
+    if (isPlainObject(objOrArr[key]) || isArray(objOrArr[key])) {
+      return hasEmptyValue(objOrArr[key]);
+    }
+  }
+  return result;
+};
+exports.hasEmptyValue = hasEmptyValue;

package/lib/date.d.ts

@@ -3,15 +3,15 @@ export interface Str2momentOptions {
     gmt?: boolean;
     picker?: 'year' | 'month' | 'week' | 'quarter';
     utcOffset?: any;
+    utc?: boolean;
 }
 export declare const getDefaultFormat: (props: any) => any;
-export declare const toGmt: (value: moment.Moment | moment.Moment[]) => string | string[] | moment.Moment | moment.Moment[];
-export declare const toLocal: (value: moment.Moment | moment.Moment[]) => string | string[] | moment.Moment | moment.Moment[];
+export declare const toGmt: (value: moment.Moment) => string | moment.Moment;
+export declare const toLocal: (value: moment.Moment) => string | any[] | moment.Moment;
 export declare const str2moment: (value?: string | string[], options?: Str2momentOptions) => any;
 export interface Moment2strOptions {
     showTime?: boolean;
     gmt?: boolean;
     picker?: 'year' | 'month' | 'week' | 'quarter';
 }
-export declare const moment2str: (value?: moment.Moment | moment.Moment[], options?: Moment2strOptions) => string | string[] | moment.Moment | moment.Moment[];
-export declare const mapDateFormat: () => (props: any) => any;
+export declare const moment2str: (value?: moment.Moment, options?: Moment2strOptions) => string | any[] | moment.Moment;

package/lib/date.js

@@ -3,39 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toLocal = exports.toGmt = exports.str2moment = exports.moment2str = exports.mapDateFormat = exports.getDefaultFormat = void 0;
-
+exports.toLocal = exports.toGmt = exports.str2moment = exports.moment2str = exports.getDefaultFormat = void 0;
 function _moment() {
   const data = _interopRequireDefault(require("moment"));
-
   _moment = function _moment() {
     return data;
   };
-
   return data;
 }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 const getDefaultFormat = props => {
   if (props.format) {
     return props.format;
   }
-
   if (props.dateFormat) {
     if (props['showTime']) {
       return `${props.dateFormat} ${props.timeFormat || 'HH:mm:ss'}`;
     }
-
     return props.dateFormat;
   }
-
   if (props['picker'] === 'month') {
     return 'YYYY-MM';
   } else if (props['picker'] === 'quarter') {
@@ -45,139 +31,90 @@ const getDefaultFormat = props => {
   } else if (props['picker'] === 'week') {
     return 'YYYY-wo';
   }
-
   return props['showTime'] ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
 };
-
 exports.getDefaultFormat = getDefaultFormat;
-
 const toGmt = value => {
-  if (!value) {
+  if (!value || !_moment().default.isMoment(value)) {
     return value;
   }
-
-  if (Array.isArray(value)) {
-    return value.map(val => `${val.format('YYYY-MM-DD')}T${val.format('HH:mm:ss.SSS')}Z`);
-  }
-
-  if (_moment().default.isMoment(value)) {
-    return `${value.format('YYYY-MM-DD')}T${value.format('HH:mm:ss.SSS')}Z`;
-  }
+  return `${value.format('YYYY-MM-DD')}T${value.format('HH:mm:ss.SSS')}Z`;
 };
-
 exports.toGmt = toGmt;
-
 const toLocal = value => {
   if (!value) {
     return value;
   }
-
   if (Array.isArray(value)) {
-    return value.map(val => val.toISOString());
+    return value.map(val => val.startOf('second').toISOString());
   }
-
   if (_moment().default.isMoment(value)) {
-    return value.toISOString();
+    return value.startOf('second').toISOString();
   }
 };
-
 exports.toLocal = toLocal;
-
 const toMoment = (val, options) => {
   if (!val) {
     return;
   }
-
   const offset = options.utcOffset || -1 * new Date().getTimezoneOffset();
-
+  const gmt = options.gmt,
+    picker = options.picker,
+    _options$utc = options.utc,
+    utc = _options$utc === void 0 ? true : _options$utc;
+  if (!utc) {
+    return (0, _moment().default)(val);
+  }
   if (_moment().default.isMoment(val)) {
     return val.utcOffset(offset);
   }
-
-  const gmt = options.gmt,
-        picker = options.picker;
-
   if (gmt || picker) {
     return (0, _moment().default)(val).utcOffset(0);
   }
-
   return (0, _moment().default)(val).utcOffset(offset);
 };
-
 const str2moment = (value, options = {}) => {
   return Array.isArray(value) ? value.map(val => {
     return toMoment(val, options);
   }) : value ? toMoment(value, options) : value;
 };
-
 exports.str2moment = str2moment;
-
 const toStringByPicker = (value, picker) => {
   if (picker === 'year') {
     return value.format('YYYY') + '-01-01T00:00:00.000Z';
   }
-
   if (picker === 'month') {
     return value.format('YYYY-MM') + '-01T00:00:00.000Z';
   }
-
   if (picker === 'quarter') {
     return value.format('YYYY-MM') + '-01T00:00:00.000Z';
   }
-
   if (picker === 'week') {
     return value.format('YYYY-MM-DD') + 'T00:00:00.000Z';
   }
-
   return value.format('YYYY-MM-DD') + 'T00:00:00.000Z';
 };
-
 const toGmtByPicker = (value, picker) => {
   if (!value) {
     return value;
   }
-
   if (Array.isArray(value)) {
     return value.map(val => toStringByPicker(val, picker));
   }
-
   if (_moment().default.isMoment(value)) {
     return toStringByPicker(value, picker);
   }
 };
-
 const moment2str = (value, options = {}) => {
   const showTime = options.showTime,
-        gmt = options.gmt,
-        picker = options.picker;
-
+    gmt = options.gmt,
+    picker = options.picker;
   if (!value) {
     return value;
   }
-
   if (showTime) {
     return gmt ? toGmt(value) : toLocal(value);
   }
-
   return toGmtByPicker(value, picker);
 };
-
-exports.moment2str = moment2str;
-
-const mapDateFormat = function mapDateFormat() {
-  return props => {
-    const format = getDefaultFormat(props);
-    const _onChange = props.onChange;
-    return _objectSpread(_objectSpread({}, props), {}, {
-      format: format,
-      value: str2moment(props.value, props),
-      onChange: value => {
-        if (_onChange) {
-          _onChange(moment2str(value, props));
-        }
-      }
-    });
-  };
-};
-
-exports.mapDateFormat = mapDateFormat;
+exports.moment2str = moment2str;

package/lib/forEach.d.ts

@@ -0,0 +1 @@
+export declare const forEach: (obj: any, callback: (value: any, key: string | number) => void) => void;