@lowdefy/operators 3.23.0 → 4.0.0-alpha.5

package/dist/nodeParser.js

@@ -1,149 +1,86 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-var _common = _interopRequireDefault(require("./common"));
-
-var _node = _interopRequireDefault(require("./node"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
-
-class NodeParser {
-  constructor() {
-    var {
-      arrayIndices,
-      input,
-      lowdefyGlobal,
-      secrets,
-      state,
-      urlQuery,
-      user
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.arrayIndices = arrayIndices;
-    this.input = input;
-    this.lowdefyGlobal = lowdefyGlobal;
-    this.secrets = secrets;
-    this.state = state;
-    this.urlQuery = urlQuery;
-    this.user = user;
-    this.parse = this.parse.bind(this);
-    this.operators = _objectSpread(_objectSpread({}, _common.default), _node.default);
-    this.operations = {};
-  }
-
-  init() {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      yield Promise.all(Object.keys(_this.operators).map( /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* (operator) {
-          var fn = require("./".concat(_this.operators[operator], ".js"));
-
-          _this.operations[operator] = fn.default;
-
-          if (_this.operations[operator].init) {
-            yield _this.operations[operator].init();
-          }
-        });
-
-        return function (_x) {
-          return _ref.apply(this, arguments);
-        };
-      }()));
-    })();
-  }
-
-  parse(_ref2) {
-    var {
-      actions,
-      args,
-      event,
-      input,
-      location
-    } = _ref2;
-
-    if (_helpers.type.isUndefined(input)) {
-      return {
-        output: input,
-        errors: []
-      };
-    }
-
-    if (event && !_helpers.type.isObject(event)) {
-      throw new Error('Operator parser event must be a object.');
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { serializer, type } from '@lowdefy/helpers';
+let NodeParser = class NodeParser {
+    async init() {
+        await Promise.all(Object.values(this.operators).map(async (operator)=>{
+            if (operator.init) {
+                await operator.init();
+            }
+        }));
     }
-
-    if (args && !_helpers.type.isArray(args)) {
-      throw new Error('Operator parser args must be an array.');
+    parse({ args , input , location  }) {
+        const operators = this.operators;
+        const secrets = this.secrets;
+        const payload = this.payload;
+        const user = this.user;
+        if (type.isUndefined(input)) {
+            return {
+                output: input,
+                errors: []
+            };
+        }
+        if (args && !type.isArray(args)) {
+            throw new Error('Operator parser args must be an array.');
+        }
+        if (!type.isString(location)) {
+            throw new Error('Operator parser location must be a string.');
+        }
+        const errors = [];
+        const reviver = (_, value)=>{
+            if (type.isObject(value) && Object.keys(value).length === 1) {
+                const key = Object.keys(value)[0];
+                const [op, methodName] = key.split('.');
+                try {
+                    if (!type.isUndefined(operators[op])) {
+                        const res = operators[op]({
+                            args,
+                            arrayIndices: [],
+                            env: 'node',
+                            location,
+                            methodName,
+                            operators: operators,
+                            params: value[key],
+                            secrets,
+                            payload,
+                            user,
+                            parser: this
+                        });
+                        return res;
+                    }
+                } catch (e) {
+                    errors.push(e);
+                    console.error(e);
+                    return null;
+                }
+            }
+            return value;
+        };
+        return {
+            output: serializer.copy(input, {
+                reviver
+            }),
+            errors
+        };
     }
-
-    if (location && !_helpers.type.isString(location)) {
-      throw new Error('Operator parser location must be a string.');
+    constructor({ payload , secrets , user , operators  }){
+        this.operators = operators;
+        this.payload = payload;
+        this.secrets = secrets;
+        this.user = user;
+        this.parse = this.parse.bind(this);
     }
-
-    var errors = [];
-
-    var reviver = (_, value) => {
-      if (_helpers.type.isObject(value) && Object.keys(value).length === 1) {
-        var key = Object.keys(value)[0];
-        var [op, methodName] = key.split('.');
-
-        try {
-          if (!_helpers.type.isUndefined(this.operations[op])) {
-            var res = this.operations[op]({
-              actions,
-              args,
-              arrayIndices: this.arrayIndices,
-              env: 'node',
-              event,
-              input: this.input,
-              location,
-              lowdefyGlobal: this.lowdefyGlobal,
-              methodName,
-              operations: this.operations,
-              params: value[key],
-              secrets: this.secrets,
-              state: this.state,
-              urlQuery: this.urlQuery,
-              user: this.user,
-              parser: this
-            });
-            return res;
-          }
-        } catch (e) {
-          errors.push(e);
-          console.error(e);
-          return null;
-        }
-      }
-
-      return value;
-    };
-
-    return {
-      output: _helpers.serializer.copy(input, {
-        reviver
-      }),
-      errors
-    };
-  }
-
-}
-
-var _default = NodeParser;
-exports.default = _default;
+};
+export default NodeParser;

package/dist/runClass.js

@@ -1,12 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
 /*
   Copyright 2020-2021 Lowdefy, Inc
 
@@ -21,82 +12,66 @@ var _helpers = require("@lowdefy/helpers");
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/
-var runClass = _ref => {
-  var {
-    location,
-    meta,
-    methodName,
-    operator,
-    params,
-    functions,
-    defaultFunction
-  } = _ref;
-
-  if (!methodName) {
-    if (meta[params]) {
-      methodName = params;
-    } else if (defaultFunction) {
-      methodName = defaultFunction;
+*/ import { type } from '@lowdefy/helpers';
+const runClass = ({ location , meta , methodName , operator , params , functions , defaultFunction  })=>{
+    if (!methodName) {
+        if (meta[params]) {
+            methodName = params;
+        } else if (defaultFunction) {
+            methodName = defaultFunction;
+        } else {
+            throw new Error(`Operator Error: ${operator} requires a valid method name, use one of the following: ${Object.keys(meta).join(', ')}.
+        Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        }
+    }
+    if (!meta[methodName] && !functions[methodName]) {
+        throw new Error(`Operator Error: ${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.
+      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    // validate params type
+    if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(type.typeOf(params))) {
+        throw new Error(`Operator Error: ${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.
+      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    if (meta[methodName].noArgs) {
+        try {
+            return functions[methodName]();
+        } catch (e) {
+            throw new Error(`Operator Error: ${operator}: - ${e.message} Received: {"${operator}":${JSON.stringify(params)}} at ${location}.`);
+        }
+    }
+    let args = [];
+    if (meta[methodName].singleArg || meta[methodName].property) {
+        args = [
+            params
+        ];
     } else {
-      throw new Error("Operator Error: ".concat(operator, " requires a valid method name, use one of the following: ").concat(Object.keys(meta).join(', '), ".\n        Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
+        if (type.isArray(params)) {
+            args = params;
+        }
+        if (type.isObject(params)) {
+            args.push(...(meta[methodName].namedArgs || []).map((key)=>params[key]
+            ));
+            if (!type.isNone(meta[methodName].spreadArgs) && !type.isArray(params[meta[methodName].spreadArgs])) {
+                throw new Error(`Operator Error: ${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.
+          Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+            }
+            args.push(...params[meta[methodName].spreadArgs] || []);
+        }
     }
-  }
-
-  if (!meta[methodName] && !functions[methodName]) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " is not supported, use one of the following: ").concat(Object.keys(meta).join(', '), ".\n      Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  } // validate params type
-
-
-  if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(_helpers.type.typeOf(params))) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " accepts one of the following types: ").concat(meta[methodName].validTypes.join(', '), ".\n      Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  }
-
-  if (meta[methodName].noArgs) {
-    try {
-      return functions[methodName]();
-    } catch (e) {
-      throw new Error("Operator Error: ".concat(operator, ": - ").concat(e.message, " Received: {\"").concat(operator, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
+    if (type.isFunction(meta[methodName].prep)) {
+        args = meta[methodName].prep(args, {
+            location
+        });
     }
-  }
-
-  var args = [];
-
-  if (meta[methodName].singleArg || meta[methodName].property) {
-    args = [params];
-  } else {
-    if (_helpers.type.isArray(params)) {
-      args = params;
+    // for property
+    if (meta[methodName].property) {
+        return functions[methodName];
     }
-
-    if (_helpers.type.isObject(params)) {
-      args.push(...(meta[methodName].namedArgs || []).map(key => params[key]));
-
-      if (!_helpers.type.isNone(meta[methodName].spreadArgs) && !_helpers.type.isArray(params[meta[methodName].spreadArgs])) {
-        throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " takes an array as input argument for ").concat(meta[methodName].spreadArgs, ".\n          Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-      }
-
-      args.push(...(params[meta[methodName].spreadArgs] || []));
+    try {
+        return functions[methodName](...args);
+    } catch (e) {
+        throw new Error(`Operator Error: ${operator}.${methodName} - ${e.message} Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
     }
-  }
-
-  if (_helpers.type.isFunction(meta[methodName].prep)) {
-    args = meta[methodName].prep(args, {
-      location
-    });
-  } // for property
-
-
-  if (meta[methodName].property) {
-    return functions[methodName];
-  }
-
-  try {
-    return functions[methodName](...args);
-  } catch (e) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " - ").concat(e.message, " Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  }
 };
-
-var _default = runClass;
-exports.default = _default;
+export default runClass;

package/dist/runInstance.js

@@ -1,12 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
 /*
   Copyright 2020-2021 Lowdefy, Inc
 
@@ -21,81 +12,66 @@ var _helpers = require("@lowdefy/helpers");
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/
-var runInstance = _ref => {
-  var {
-    location,
-    meta,
-    methodName,
-    operator,
-    params,
-    instanceType
-  } = _ref;
-
-  if (!meta[methodName]) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " is not supported, use one of the following: ").concat(Object.keys(meta).join(', '), ".\n      Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  } // validate params type
-
-
-  if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(_helpers.type.typeOf(params))) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " accepts one of the following types: ").concat(meta[methodName].validTypes.join(', '), ".\n      Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  }
-
-  var instance;
-  var args = [];
-
-  if (meta[methodName].singleArg || meta[methodName].property) {
-    instance = params;
-  } else {
-    if (_helpers.type.isArray(params)) {
-      // Instance must be zero in list args.
-      instance = params[0];
-      args = params.slice(1);
-    } // Instance must be listed first in named args.
-
-
-    if (_helpers.type.isObject(params)) {
-      instance = params[meta[methodName].namedArgs[0]];
-      args.push(...meta[methodName].namedArgs.slice(1).map(key => params[key]));
-
-      if (!_helpers.type.isNone(meta[methodName].spreadArgs) && !_helpers.type.isArray(params[meta[methodName].spreadArgs])) {
-        throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " takes an array as input argument for ").concat(meta[methodName].spreadArgs, ".\n          Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-      }
-
-      args.push(...(params[meta[methodName].spreadArgs] || []));
+*/ import { type } from '@lowdefy/helpers';
+const runInstance = ({ location , meta , methodName , operator , params , instanceType  })=>{
+    if (!meta[methodName]) {
+        throw new Error(`Operator Error: ${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.
+      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
     }
-  }
-
-  if (_helpers.type.isFunction(meta[methodName].prep)) {
-    [instance, ...args] = meta[methodName].prep([instance, ...args]);
-  }
-
-  if (_helpers.type.typeOf(instance) !== instanceType) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " must be evaluated on an ").concat(instanceType, " instance. For named args provide an ").concat(instanceType, " instance to the \"on\" property, for listed args provide and ").concat(instanceType, " instance as the first element in the operator argument array.\n    Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  } // Error for invalid method key.
-
-
-  if (_helpers.type.isNone(instance[methodName])) {
-    throw new Error("Operator Error: ".concat(operator, " must be evaluated using one of the following: ").concat(Object.keys(meta).join(', '), ".\n      Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  } // for property
-
-
-  if (meta[methodName].property) {
-    return instance[methodName];
-  }
-
-  try {
-    var result = instance[methodName](...args);
-
-    if (meta[methodName].returnInstance) {
-      return instance;
+    // validate params type
+    if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(type.typeOf(params))) {
+        throw new Error(`Operator Error: ${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.
+      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    let instance;
+    let args = [];
+    if (meta[methodName].singleArg || meta[methodName].property) {
+        instance = params;
+    } else {
+        if (type.isArray(params)) {
+            // Instance must be zero in list args.
+            instance = params[0];
+            args = params.slice(1);
+        }
+        // Instance must be listed first in named args.
+        if (type.isObject(params)) {
+            instance = params[meta[methodName].namedArgs[0]];
+            args.push(...meta[methodName].namedArgs.slice(1).map((key)=>params[key]
+            ));
+            if (!type.isNone(meta[methodName].spreadArgs) && !type.isArray(params[meta[methodName].spreadArgs])) {
+                throw new Error(`Operator Error: ${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.
+          Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+            }
+            args.push(...params[meta[methodName].spreadArgs] || []);
+        }
+    }
+    if (type.isFunction(meta[methodName].prep)) {
+        [instance, ...args] = meta[methodName].prep([
+            instance,
+            ...args
+        ]);
+    }
+    if (type.typeOf(instance) !== instanceType) {
+        throw new Error(`Operator Error: ${operator}.${methodName} must be evaluated on an ${instanceType} instance. For named args provide an ${instanceType} instance to the "on" property, for listed args provide and ${instanceType} instance as the first element in the operator argument array.
+    Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    // Error for invalid method key.
+    if (type.isNone(instance[methodName])) {
+        throw new Error(`Operator Error: ${operator} must be evaluated using one of the following: ${Object.keys(meta).join(', ')}.
+      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    // for property
+    if (meta[methodName].property) {
+        return instance[methodName];
+    }
+    try {
+        const result = instance[methodName](...args);
+        if (meta[methodName].returnInstance) {
+            return instance;
+        }
+        return result;
+    } catch (e) {
+        throw new Error(`Operator Error: ${operator}.${methodName} - ${e.message} Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
     }
-
-    return result;
-  } catch (e) {
-    throw new Error("Operator Error: ".concat(operator, ".").concat(methodName, " - ").concat(e.message, " Received: {\"").concat(operator, ".").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  }
 };
-
-var _default = runInstance;
-exports.default = _default;
+export default runInstance;

package/dist/web/format.js

@@ -1,16 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-var _format2 = _interopRequireDefault(require("@lowdefy/format"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /*
   Copyright 2020-2021 Lowdefy, Inc
 
@@ -25,28 +12,19 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/
-function _format(_ref) {
-  var {
-    location,
-    methodName,
-    params
-  } = _ref;
-
-  if (!_format2.default[methodName]) {
-    throw new Error("Operator Error: $_format.".concat(methodName, " is not supported, use one of the following: ").concat(Object.keys(_format2.default).join(', '), ".\n      Received: {\"_format.").concat(methodName, "\":").concat(JSON.stringify(params), "} at ").concat(location, "."));
-  }
-
-  if (!_helpers.type.isObject(params)) {
-    throw new Error("Operator Error: _format takes an object as arguments. Received: ".concat(JSON.stringify(params), " at ").concat(location, "."));
-  }
-
-  if (!_helpers.type.isObject(params.params) && !_helpers.type.isUndefined(params.params)) {
-    throw new Error("Operator Error: _format params argument should be an object or undefined. Received: ".concat(JSON.stringify(params), " at ").concat(location, "."));
-  }
-
-  return _format2.default[methodName](params.params)(params.on);
+*/ import { type } from '@lowdefy/helpers';
+import formatters from '@lowdefy/format';
+function _format({ location , methodName , params  }) {
+    if (!formatters[methodName]) {
+        throw new Error(`Operator Error: $_format.${methodName} is not supported, use one of the following: ${Object.keys(formatters).join(', ')}.
+      Received: {"_format.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    }
+    if (!type.isObject(params)) {
+        throw new Error(`Operator Error: _format takes an object as arguments. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (!type.isObject(params.params) && !type.isUndefined(params.params)) {
+        throw new Error(`Operator Error: _format params argument should be an object or undefined. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return formatters[methodName](params.params)(params.on);
 }
-
-var _default = _format;
-exports.default = _default;
+export default _format;

package/dist/web/index.js

@@ -1,10 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
 /*
   Copyright 2020-2021 Lowdefy, Inc
 
@@ -19,18 +12,21 @@ exports.default = void 0;
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/
-var _default = {
-  _actions: 'web/actions',
-  _event_log: 'web/event_log',
-  _base64: 'web/base64',
-  _format: 'web/format',
-  _list_contexts: 'web/list_contexts',
-  _location: 'web/location',
-  _js: 'web/js',
-  _media: 'web/media',
-  _menu: 'web/menu',
-  _request_details: 'web/request_details',
-  _request: 'web/request'
+*/ export default {
+    _actions: 'web/actions',
+    _base64: 'web/base64',
+    _event_log: 'web/event_log',
+    _event: 'web/event',
+    _format: 'web/format',
+    _global: 'web/global',
+    _index: 'web/_index',
+    _input: 'web/input',
+    _js: 'web/js',
+    _location: 'web/location',
+    _media: 'web/media',
+    _menu: 'web/menu',
+    _request_details: 'web/request_details',
+    _request: 'web/request',
+    _state: 'web/state',
+    _url_query: 'web/url_query'
 };
-exports.default = _default;