@lowdefy/engine 3.23.3 → 4.0.0-alpha.11

package/dist/actions/createSetState.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2022 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 { applyArrayIndices } from '@lowdefy/helpers';
+function createSetState({ arrayIndices , context  }) {
+    return function setState(params) {
+        Object.keys(params).forEach((key)=>{
+            context._internal.State.set(applyArrayIndices(arrayIndices, key), params[key]);
+        });
+        context._internal.RootBlocks.reset();
+        context._internal.update();
+    };
+}
+export default createSetState;

package/dist/actions/createValidate.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2022 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 getBlockMatcher from '../getBlockMatcher.js';
+function createValidate({ context  }) {
+    return function validate(params) {
+        const validationErrors = context._internal.RootBlocks.validate(getBlockMatcher(params));
+        if (validationErrors.length > 0) {
+            const error = new Error(`Your input has ${validationErrors.length} validation error${validationErrors.length !== 1 ? 's' : ''}.`);
+            throw error;
+        }
+    };
+}
+export default createValidate;

package/dist/actions/getActionMethods.js

@@ -0,0 +1,61 @@
+/*
+  Copyright 2020-2022 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 createCallMethod from './createCallMethod.js';
+import createGetActions from './createGetActions.js';
+import createGetBlockId from './createGetBlockId.js';
+import createGetEvent from './createGetEvent.js';
+import createGetGlobal from './createGetGlobal.js';
+import createGetInput from './createGetInput.js';
+import createGetPageId from './createGetPageId.js';
+import createGetRequestDetails from './createGetRequestDetails.js';
+import createGetState from './createGetState.js';
+import createGetUrlQuery from './createGetUrlQuery.js';
+import createGetUser from './createGetUser.js';
+import createLink from './createLink.js';
+import createLogin from './createLogin.js';
+import createLogout from './createLogout.js';
+import createDisplayMessage from './createDisplayMessage.js';
+import createRequest from './createRequest.js';
+import createReset from './createReset.js';
+import createResetValidation from './createResetValidation.js';
+import createSetGlobal from './createSetGlobal.js';
+import createSetState from './createSetState.js';
+import createValidate from './createValidate.js';
+function getActionMethods(props) {
+    return {
+        callMethod: createCallMethod(props),
+        displayMessage: createDisplayMessage(props),
+        getActions: createGetActions(props),
+        getBlockId: createGetBlockId(props),
+        getEvent: createGetEvent(props),
+        getGlobal: createGetGlobal(props),
+        getInput: createGetInput(props),
+        getPageId: createGetPageId(props),
+        getRequestDetails: createGetRequestDetails(props),
+        getState: createGetState(props),
+        getUrlQuery: createGetUrlQuery(props),
+        getUser: createGetUser(props),
+        link: createLink(props),
+        login: createLogin(props),
+        logout: createLogout(props),
+        request: createRequest(props),
+        reset: createReset(props),
+        resetValidation: createResetValidation(props),
+        setGlobal: createSetGlobal(props),
+        setState: createSetState(props),
+        validate: createValidate(props)
+    };
+}
+export default getActionMethods;

package/dist/actions/getFromObject.js

@@ -0,0 +1,42 @@
+/*
+  Copyright 2020-2022 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 { applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
+const getFromObject = ({ arrayIndices , location , method , object , params  })=>{
+    if (params === true) params = {
+        all: true
+    };
+    if (type.isString(params) || type.isInt(params)) params = {
+        key: params
+    };
+    if (!type.isObject(params)) {
+        throw new Error(`Method Error: ${method} params must be of type string, integer, boolean or object. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (params.key === null) return get(params, 'default', {
+        default: null,
+        copy: true
+    });
+    if (params.all === true) return serializer.copy(object);
+    if (!type.isString(params.key) && !type.isInt(params.key)) {
+        throw new Error(`Method Error: ${method} params.key must be of type string or integer. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return get(object, applyArrayIndices(arrayIndices, params.key), {
+        default: get(params, 'default', {
+            default: null,
+            copy: true
+        }),
+        copy: true
+    });
+};
+export default getFromObject;

package/dist/createLink.js

@@ -1,16 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-var _engine = require("@lowdefy/engine");
-
 /*
-  Copyright 2020-2021 Lowdefy, Inc
+  Copyright 2020-2022 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -23,53 +12,57 @@ var _engine = require("@lowdefy/engine");
   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 createLink(_ref) {
-  var {
-    backLink,
-    lowdefy,
-    newOriginLink,
-    sameOriginLink
-  } = _ref;
-
-  function link(_ref2) {
-    var {
-      back,
-      home,
-      input,
-      newTab,
-      pageId,
-      url,
-      urlQuery
-    } = _ref2;
-
-    if (back) {
-      return backLink();
+*/ import { type, urlQuery as urlQueryFn } from '@lowdefy/helpers';
+function createLink({ backLink , disabledLink , lowdefy , newOriginLink , noLink , sameOriginLink  }) {
+    function link(props) {
+        if (props.disabled === true) {
+            return disabledLink(props);
+        }
+        if ([
+            !props.pageId,
+            !props.back,
+            !props.home,
+            !props.url
+        ].filter((v)=>!v
+        ).length > 1) {
+            throw Error(`Invalid Link: To avoid ambiguity, only one of 'back', 'home', 'pageId' or 'url' can be defined.`);
+        }
+        if (props.back === true) {
+            // Cannot set input or urlQuery on back
+            return backLink(props);
+        }
+        const query = type.isNone(props.urlQuery) ? '' : `${urlQueryFn.stringify(props.urlQuery)}`;
+        if (props.home === true) {
+            const pathname = `/${lowdefy.home.configured ? '' : lowdefy.home.pageId}`;
+            return sameOriginLink({
+                ...props,
+                pathname,
+                query,
+                setInput: ()=>{
+                    lowdefy.inputs[`page:${lowdefy.home.pageId}`] = props.input || {};
+                }
+            });
+        }
+        if (type.isString(props.pageId)) {
+            return sameOriginLink({
+                ...props,
+                pathname: `/${props.pageId}`,
+                query,
+                setInput: ()=>{
+                    lowdefy.inputs[`page:${props.pageId}`] = props.input || {};
+                }
+            });
+        }
+        if (type.isString(props.url)) {
+            const protocol = props.url.includes(':') ? '' : 'https://';
+            return newOriginLink({
+                ...props,
+                url: `${protocol}${props.url}`,
+                query
+            });
+        }
+        return noLink(props);
     }
-
-    var lowdefyUrlQuery = _helpers.type.isNone(urlQuery) ? '' : "?".concat(_helpers.urlQuery.stringify(urlQuery));
-    if (home) pageId = lowdefy.homePageId;
-
-    if (pageId) {
-      if (!_helpers.type.isNone(input)) {
-        var nextContextId = (0, _engine.makeContextId)({
-          pageId,
-          urlQuery: urlQuery,
-          blockId: pageId
-        });
-        lowdefy.inputs[nextContextId] = input;
-      }
-
-      return sameOriginLink("/".concat(pageId).concat(lowdefyUrlQuery), newTab);
-    } else if (url) {
-      return newOriginLink("".concat(url).concat(lowdefyUrlQuery), newTab);
-    } else {
-      throw new Error("Invalid Link.");
-    }
-  }
-
-  return link;
+    return link;
 }
-
-var _default = createLink;
-exports.default = _default;
+export default createLink;

package/dist/getBlockMatcher.js

@@ -1,14 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
 /*
-  Copyright 2020-2021 Lowdefy, Inc
+  Copyright 2020-2022 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -21,55 +12,52 @@ 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 getBlockMatcher = params => {
-  var testParams = params;
-  if (_helpers.type.isNone(testParams)) return () => true;
-
-  if (_helpers.type.isString(testParams)) {
-    testParams = {
-      blockIds: [testParams]
-    };
-  }
-
-  if (_helpers.type.isArray(testParams) || _helpers.type.isBoolean(testParams)) {
-    testParams = {
-      blockIds: testParams
-    };
-  }
-
-  if (!_helpers.type.isObject(testParams)) {
-    throw new Error('Invalid validate params.');
-  }
-
-  if (_helpers.type.isString(testParams.blockIds)) {
-    testParams.blockIds = [testParams.blockIds];
-  }
-
-  if (_helpers.type.isString(testParams.regex)) {
-    testParams.regex = [testParams.regex];
-  }
-
-  if (_helpers.type.isArray(testParams.regex)) {
-    testParams.regex = testParams.regex.map(regex => new RegExp(regex));
-  }
-
-  return id => {
-    if (testParams.blockIds === true || _helpers.type.isArray(testParams.blockIds) && testParams.blockIds.includes(id)) {
-      return true;
+*/ import { type } from '@lowdefy/helpers';
+const getBlockMatcher = (params)=>{
+    let testParams = params;
+    if (type.isNone(testParams)) return ()=>true
+    ;
+    if (type.isString(testParams)) {
+        testParams = {
+            blockIds: [
+                testParams
+            ]
+        };
     }
-
-    if (_helpers.type.isArray(testParams.regex)) {
-      for (var regex of testParams.regex) {
-        if (regex.test(id)) {
-          return true;
-        }
-      }
+    if (type.isArray(testParams) || type.isBoolean(testParams)) {
+        testParams = {
+            blockIds: testParams
+        };
     }
-
-    return false;
-  };
+    if (!type.isObject(testParams)) {
+        throw new Error('Invalid validate params.');
+    }
+    if (type.isString(testParams.blockIds)) {
+        testParams.blockIds = [
+            testParams.blockIds
+        ];
+    }
+    if (type.isString(testParams.regex)) {
+        testParams.regex = [
+            testParams.regex
+        ];
+    }
+    if (type.isArray(testParams.regex)) {
+        testParams.regex = testParams.regex.map((regex)=>new RegExp(regex)
+        );
+    }
+    return (id)=>{
+        if (testParams.blockIds === true || type.isArray(testParams.blockIds) && testParams.blockIds.includes(id)) {
+            return true;
+        }
+        if (type.isArray(testParams.regex)) {
+            for (const regex of testParams.regex){
+                if (regex.test(id)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
 };
-
-var _default = getBlockMatcher;
-exports.default = _default;
+export default getBlockMatcher;

package/dist/getContext.js

@@ -1,151 +1,114 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _operators = require("@lowdefy/operators");
-
-var _Actions = _interopRequireDefault(require("./Actions"));
-
-var _Blocks = _interopRequireDefault(require("./Blocks"));
-
-var _Requests = _interopRequireDefault(require("./Requests"));
-
-var _State = _interopRequireDefault(require("./State"));
-
-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); }); }; }
-
-var blockData = _ref => {
-  var {
-    areas,
-    blockId,
-    blocks,
-    events,
-    field,
-    id,
-    layout,
-    meta,
-    operators,
-    pageId,
-    properties,
-    requests,
-    required,
-    style,
-    type,
-    validate,
-    visible
-  } = _ref;
-  return {
-    areas,
-    blockId,
-    blocks,
-    events,
-    field,
-    id,
-    layout,
-    meta,
-    operators,
-    pageId,
-    properties,
-    requests,
-    required,
-    style,
-    type,
-    validate,
-    visible
-  };
-};
-
-var getContext = /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator(function* (_ref2) {
-    var {
-      block,
-      contextId,
-      lowdefy
-    } = _ref2;
-
-    if (lowdefy.contexts[contextId]) {
-      lowdefy.contexts[contextId].update();
-      return lowdefy.contexts[contextId];
+/*
+  Copyright 2020-2022 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 { WebParser } from '@lowdefy/operators';
+import Actions from './Actions.js';
+import Blocks from './Blocks.js';
+import Requests from './Requests.js';
+import State from './State.js';
+const blockData = ({ areas , blockId , blocks , events , field , id , layout , pageId , properties , requests , required , style , type , validate , visible ,  })=>({
+        areas,
+        blockId,
+        blocks,
+        events,
+        field,
+        id,
+        layout,
+        pageId,
+        properties,
+        requests,
+        required,
+        style,
+        type,
+        validate,
+        visible
+    })
+;
+function getContext({ config , lowdefy , resetContext ={
+    reset: false,
+    setReset: ()=>undefined
+} ,  }) {
+    if (!config) {
+        throw new Error('A page must be provided to get context.');
     }
-
-    if (!block) {
-      throw new Error('A block must be provided to get context.');
-    } // eslint-disable-next-line no-param-reassign
-
-
-    if (!lowdefy.inputs[contextId]) {
-      lowdefy.inputs[contextId] = {};
+    const { id  } = config;
+    if (lowdefy.contexts[id] && !resetContext.reset) {
+        // memoize context if already created, eg between page transitions, unless the reset flag is raised
+        lowdefy.contexts[id]._internal.update();
+        return lowdefy.contexts[id];
     }
-
-    var operatorsSet = new Set([...block.operators, '_not', '_type']);
-    lowdefy.contexts[contextId] = {
-      id: contextId,
-      blockId: block.blockId,
-      eventLog: [],
-      requests: {},
-      operators: [...operatorsSet],
-      lowdefy,
-      pageId: lowdefy.pageId,
-      rootBlock: blockData(block),
-      // filter block to prevent circular structure
-      state: {},
-      update: () => {},
-      // Initialize update since Requests might call it during context creation
-      updateListeners: new Set()
+    resetContext.setReset(false); // lower context reset flag.
+    if (!lowdefy.inputs[id]) {
+        lowdefy.inputs[id] = {};
+    }
+    const ctx = {
+        id: id,
+        pageId: config.pageId,
+        eventLog: [],
+        requests: {},
+        state: {},
+        _internal: {
+            lowdefy,
+            rootBlock: blockData(config),
+            update: ()=>{}
+        }
     };
-    var ctx = lowdefy.contexts[contextId];
-    ctx.parser = new _operators.WebParser({
-      context: ctx,
-      contexts: lowdefy.contexts
+    const _internal = ctx._internal;
+    _internal.parser = new WebParser({
+        context: ctx,
+        operators: lowdefy._internal.operators
     });
-    yield ctx.parser.init();
-    ctx.State = new _State.default(ctx);
-    ctx.Actions = new _Actions.default(ctx);
-    ctx.Requests = new _Requests.default(ctx);
-    ctx.RootBlocks = new _Blocks.default({
-      areas: {
-        root: {
-          blocks: [ctx.rootBlock]
-        }
-      },
-      context: ctx
+    _internal.State = new State(ctx);
+    _internal.Actions = new Actions(ctx);
+    _internal.Requests = new Requests(ctx);
+    _internal.RootBlocks = new Blocks({
+        areas: {
+            root: {
+                blocks: [
+                    _internal.rootBlock
+                ]
+            }
+        },
+        context: ctx
     });
-    ctx.RootBlocks.init();
-
-    ctx.update = () => {
-      ctx.RootBlocks.update();
-      [...ctx.updateListeners].forEach(listenId => {
-        // Will loop infinitely if update is called on self
-        if (!lowdefy.contexts[listenId] || listenId === contextId) {
-          ctx.updateListeners.delete(listenId);
-        } else {
-          lowdefy.contexts[listenId].update();
+    _internal.RootBlocks.init();
+    _internal.update = ()=>{
+        _internal.RootBlocks.update();
+    };
+    _internal.runOnInit = async (progress)=>{
+        progress();
+        if (!_internal.onInitDone) {
+            await _internal.RootBlocks.areas.root.blocks[0].triggerEvent({
+                name: 'onInit',
+                progress
+            });
+            _internal.update();
+            _internal.State.freezeState();
+            _internal.onInitDone = true;
         }
-      });
     };
-
-    yield ctx.RootBlocks.map[ctx.blockId].triggerEvent({
-      name: 'onInit'
-    });
-    ctx.update();
-    ctx.State.freezeState();
-    ctx.RootBlocks.map[ctx.blockId].triggerEvent({
-      name: 'onInitAsync'
-    });
+    _internal.runOnInitAsync = async (progress)=>{
+        if (_internal.onInitDone && !_internal.onInitAsyncDone) {
+            await _internal.RootBlocks.areas.root.blocks[0].triggerEvent({
+                name: 'onInitAsync',
+                progress
+            });
+            _internal.onInitAsyncDone = true;
+        }
+    };
+    ctx._internal.update();
+    lowdefy.contexts[id] = ctx;
     return ctx;
-  });
-
-  return function getContext(_x) {
-    return _ref3.apply(this, arguments);
-  };
-}();
-
-var _default = getContext;
-exports.default = _default;
+}
+export default getContext;