@kaspernj/api-maker 1.0.445 → 1.0.447

package/build/preloaded.js

@@ -0,0 +1,38 @@
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+export default class ApiMakerPreloaded {
+  constructor(response) {
+    this.response = response;
+    this.loadPreloadedModels();
+  }
+  loadPreloadedModels() {
+    this.preloaded = {};
+    for (const preloadedType in this.response.preloaded) {
+      const modelClassName = inflection.classify(preloadedType);
+      const ModelClass = modelClassRequire(modelClassName);
+      for (const preloadedId in this.response.preloaded[preloadedType]) {
+        const preloadedData = this.response.preloaded[preloadedType][preloadedId];
+        const model = new ModelClass({
+          data: preloadedData,
+          isNewRecord: false
+        });
+        if (!this.preloaded[preloadedType]) {
+          this.preloaded[preloadedType] = {};
+        }
+        this.preloaded[preloadedType][preloadedId] = model;
+      }
+    }
+    for (const modelType in this.preloaded) {
+      for (const modelId in this.preloaded[modelType]) {
+        this.preloaded[modelType][modelId]._readPreloadedRelationships(this);
+      }
+    }
+  }
+  getModel(type, id) {
+    if (!this.preloaded[type] || !this.preloaded[type][id]) {
+      throw new Error(`Could not find a ${type} by that ID: ${id}`);
+    }
+    return this.preloaded[type][id];
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/resize-observer.js

@@ -0,0 +1,11 @@
+import memo from "set-state-compare/src/memo";
+import useResizeObserver from "./use-resize-observer";
+const ApiMakerResizeObserver = memo(({
+  element,
+  onResize
+}) => {
+  useResizeObserver(element, onResize);
+  return null;
+});
+export default ApiMakerResizeObserver;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtZW1vIiwidXNlUmVzaXplT2JzZXJ2ZXIiLCJBcGlNYWtlclJlc2l6ZU9ic2VydmVyIiwiZWxlbWVudCIsIm9uUmVzaXplIl0sInNvdXJjZXMiOlsiLi4vc3JjL3Jlc2l6ZS1vYnNlcnZlci5qc3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IG1lbW8gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL3NyYy9tZW1vXCJcbmltcG9ydCB1c2VSZXNpemVPYnNlcnZlciBmcm9tIFwiLi91c2UtcmVzaXplLW9ic2VydmVyXCJcblxuY29uc3QgQXBpTWFrZXJSZXNpemVPYnNlcnZlciA9IG1lbW8oKHtlbGVtZW50LCBvblJlc2l6ZX0pID0+IHtcbiAgdXNlUmVzaXplT2JzZXJ2ZXIoZWxlbWVudCwgb25SZXNpemUpXG5cbiAgcmV0dXJuIG51bGxcbn0pXG5cbmV4cG9ydCBkZWZhdWx0IEFwaU1ha2VyUmVzaXplT2JzZXJ2ZXJcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsSUFBSSxNQUFNLDRCQUE0QjtBQUM3QyxPQUFPQyxpQkFBaUIsTUFBTSx1QkFBdUI7QUFFckQsTUFBTUMsc0JBQXNCLEdBQUdGLElBQUksQ0FBQyxDQUFDO0VBQUNHLE9BQU87RUFBRUM7QUFBUSxDQUFDLEtBQUs7RUFDM0RILGlCQUFpQixDQUFDRSxPQUFPLEVBQUVDLFFBQVEsQ0FBQztFQUVwQyxPQUFPLElBQUk7QUFDYixDQUFDLENBQUM7QUFFRixlQUFlRixzQkFBc0IiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/result.js

@@ -0,0 +1,13 @@
+export default class ApiMakerResult {
+  constructor(data) {
+    this.data = data;
+  }
+  count = () => this.data.response.meta.count;
+  currentPage = () => this.data.response.meta.currentPage;
+  models = () => this.data.models;
+  modelClass = () => this.data.collection.modelClass();
+  perPage = () => this.data.response.meta.perPage;
+  totalCount = () => this.data.response.meta.totalCount;
+  totalPages = () => this.data.response.meta.totalPages;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJBcGlNYWtlclJlc3VsdCIsImNvbnN0cnVjdG9yIiwiZGF0YSIsImNvdW50IiwicmVzcG9uc2UiLCJtZXRhIiwiY3VycmVudFBhZ2UiLCJtb2RlbHMiLCJtb2RlbENsYXNzIiwiY29sbGVjdGlvbiIsInBlclBhZ2UiLCJ0b3RhbENvdW50IiwidG90YWxQYWdlcyJdLCJzb3VyY2VzIjpbIi4uL3NyYy9yZXN1bHQuanMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXBpTWFrZXJSZXN1bHQge1xuICBjb25zdHJ1Y3RvciAoZGF0YSkge1xuICAgIHRoaXMuZGF0YSA9IGRhdGFcbiAgfVxuXG4gIGNvdW50ID0gKCkgPT4gdGhpcy5kYXRhLnJlc3BvbnNlLm1ldGEuY291bnRcbiAgY3VycmVudFBhZ2UgPSAoKSA9PiB0aGlzLmRhdGEucmVzcG9uc2UubWV0YS5jdXJyZW50UGFnZVxuICBtb2RlbHMgPSAoKSA9PiB0aGlzLmRhdGEubW9kZWxzXG4gIG1vZGVsQ2xhc3MgPSAoKSA9PiB0aGlzLmRhdGEuY29sbGVjdGlvbi5tb2RlbENsYXNzKClcbiAgcGVyUGFnZSA9ICgpID0+IHRoaXMuZGF0YS5yZXNwb25zZS5tZXRhLnBlclBhZ2VcbiAgdG90YWxDb3VudCA9ICgpID0+IHRoaXMuZGF0YS5yZXNwb25zZS5tZXRhLnRvdGFsQ291bnRcbiAgdG90YWxQYWdlcyA9ICgpID0+IHRoaXMuZGF0YS5yZXNwb25zZS5tZXRhLnRvdGFsUGFnZXNcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZSxNQUFNQSxjQUFjLENBQUM7RUFDbENDLFdBQVdBLENBQUVDLElBQUksRUFBRTtJQUNqQixJQUFJLENBQUNBLElBQUksR0FBR0EsSUFBSTtFQUNsQjtFQUVBQyxLQUFLLEdBQUdBLENBQUEsS0FBTSxJQUFJLENBQUNELElBQUksQ0FBQ0UsUUFBUSxDQUFDQyxJQUFJLENBQUNGLEtBQUs7RUFDM0NHLFdBQVcsR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ0osSUFBSSxDQUFDRSxRQUFRLENBQUNDLElBQUksQ0FBQ0MsV0FBVztFQUN2REMsTUFBTSxHQUFHQSxDQUFBLEtBQU0sSUFBSSxDQUFDTCxJQUFJLENBQUNLLE1BQU07RUFDL0JDLFVBQVUsR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ04sSUFBSSxDQUFDTyxVQUFVLENBQUNELFVBQVUsQ0FBQyxDQUFDO0VBQ3BERSxPQUFPLEdBQUdBLENBQUEsS0FBTSxJQUFJLENBQUNSLElBQUksQ0FBQ0UsUUFBUSxDQUFDQyxJQUFJLENBQUNLLE9BQU87RUFDL0NDLFVBQVUsR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ1QsSUFBSSxDQUFDRSxRQUFRLENBQUNDLElBQUksQ0FBQ00sVUFBVTtFQUNyREMsVUFBVSxHQUFHQSxDQUFBLEtBQU0sSUFBSSxDQUFDVixJQUFJLENBQUNFLFFBQVEsQ0FBQ0MsSUFBSSxDQUFDTyxVQUFVO0FBQ3ZEIiwiaWdub3JlTGlzdCI6W119

package/build/router/route.js

@@ -0,0 +1,262 @@
+import BaseComponent from "../base-component";
+import { createContext, useContext, useMemo } from "react";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import Switch, { CurrentSwitchContext } from "./switch";
+const CurrentPathContext = /*#__PURE__*/createContext([]);
+const ParamsContext = /*#__PURE__*/createContext({});
+const RequireComponentContext = /*#__PURE__*/createContext(null);
+const RouteContext = /*#__PURE__*/createContext(null);
+const useParams = () => useContext(ParamsContext);
+const Route = memo(shapeComponent(class Route extends BaseComponent {
+  static defaultProps = {
+    exact: false,
+    fallback: false,
+    includeInPath: true
+  };
+  static propTypes = propTypesExact({
+    children: PropTypes.node,
+    component: PropTypes.string,
+    componentPath: PropTypes.string,
+    exact: PropTypes.bool.isRequired,
+    fallback: PropTypes.bool.isRequired,
+    includeInPath: PropTypes.bool.isRequired,
+    onMatch: PropTypes.func,
+    path: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(RegExp)])
+  });
+  match = null;
+  newParams = null;
+  pathParts = null;
+  setup() {
+    const {
+      path
+    } = this.props;
+    const {
+      pathsMatched,
+      switchGroup
+    } = useContext(CurrentSwitchContext);
+    const givenRoute = useContext(RouteContext);
+    const {
+      pathShown
+    } = switchGroup.s;
+    this.debug = false;
+    this.log(() => ({
+      givenRoute
+    }));
+    this.requireComponent = useContext(RequireComponentContext);
+    this.currentParams = useContext(ParamsContext);
+    this.currentPath = useContext(CurrentPathContext);
+    this.switchGroup = switchGroup;
+    this.routeParts = useMemo(() => givenRoute?.split("/"), [path, givenRoute]);
+    this.pathParts = useMemo(() => path?.split("/"), [path]);
+    this.newRouteParts = useMemo(() => {
+      if (!path) {
+        if (givenRoute == "") {
+          return [];
+        } else {
+          return this.routeParts;
+        }
+      }
+      return this.routeParts.slice(this.pathParts.length, this.routeParts.length);
+    }, [givenRoute].concat(this.pathParts));
+    this.useStates({
+      Component: null,
+      componentNotFound: null,
+      matches: false
+    });
+    useMemo(() => {
+      this.loadMatches();
+    }, [givenRoute, path, pathsMatched]);
+    useMemo(() => {
+      if (this.hasSwitchMatch() && !this.s.Component && this.s.matches) {
+        if (this.props.onMatch) {
+          this.props.onMatch();
+        }
+        if (!this.props.children && (this.props.path || this.props.component || this.props.componentPath)) {
+          this.loadComponent();
+        }
+      }
+    }, [path, pathShown, this.s.matches]);
+  }
+  hasSwitchMatch = () => this.switchGroup.s.pathShown && this.switchGroup.s.pathShown == this.pathId();
+  pathId() {
+    const {
+      fallback
+    } = this.p;
+    const {
+      path
+    } = this.props;
+    let pathId;
+    if (fallback) {
+      pathId = "[FALLBACK]";
+    } else if (!path) {
+      pathId = "[PATH-EMPTY]";
+    } else {
+      pathId = path;
+    }
+    return pathId;
+  }
+  loadMatches() {
+    const {
+      newRouteParts
+    } = this.tt;
+    const {
+      component,
+      path
+    } = this.props;
+    const {
+      exact,
+      includeInPath,
+      fallback
+    } = this.p;
+    let matches = true;
+    const params = {};
+    const componentPathParts = [...this.currentPath];
+    this.log(() => [this.props.path, "Start generating component paths", JSON.stringify(componentPathParts)]);
+    for (const pathPartIndex in this.pathParts) {
+      const pathPart = this.pathParts[pathPartIndex];
+      const translatedPathPart = I18n.t(`routes.${pathPart}`, {
+        defaultValue: pathPart
+      });
+      if (!(pathPartIndex in this.routeParts)) {
+        this.log(() => `No match for: ${pathPartIndex}`);
+        matches = false;
+        break;
+      }
+      const routePart = decodeURIComponent(this.routeParts[pathPartIndex]);
+      if (pathPart.startsWith(":") && routePart) {
+        const paramName = pathPart.slice(1, pathPart.length);
+        params[paramName] = routePart;
+      } else if (translatedPathPart != routePart) {
+        matches = false;
+        break;
+      } else if (!component && includeInPath) {
+        componentPathParts.push(pathPart);
+      }
+    }
+    if (exact && newRouteParts.length > 0) {
+      this.log(() => ["Exact and more route parts", {
+        newRouteParts,
+        pathParts: this.pathParts,
+        routeParts: this.routeParts
+      }]);
+      matches = false;
+    } else if (matches && path) {
+      matches = true;
+    } else if (this.routeParts.length == 0) {
+      matches = true;
+    }
+    const matchId = this.pathId();
+    if (!matches && fallback) {
+      matches = true;
+    }
+    this.log(() => [this.props.path, "End generating component paths", JSON.stringify(componentPathParts), {
+      matches
+    }]);
+    if (matches) {
+      if (component && includeInPath) {
+        componentPathParts.push(component);
+      }
+      const newParams = Object.assign({}, this.currentParams, params);
+      this.setInstance({
+        componentPathParts,
+        match: {
+          params
+        },
+        newParams
+      });
+      this.setState({
+        matches
+      });
+      this.switchGroup?.setPathMatched(matchId, true);
+    } else {
+      this.setInstance({
+        componentPathParts: null,
+        match: null,
+        newParams: null
+      });
+      this.setState({
+        matches
+      });
+      this.switchGroup?.setPathMatched(matchId, false);
+    }
+  }
+  async loadComponent() {
+    const actualComponentPath = this.props.componentPath || this.tt.componentPathParts.join("/");
+    let Component;
+    this.log(() => ["loadComponent", {
+      componentPath: this.props.componentPath,
+      componentPathParts: this.componentPathParts,
+      actualComponentPath
+    }]);
+    try {
+      const componentImport = await this.tt.requireComponent({
+        routeDefinition: {
+          component: actualComponentPath
+        }
+      });
+      Component = componentImport.default;
+    } catch (error) {
+      console.error(`Couldn't find component: ${actualComponentPath}`);
+      throw error;
+    }
+    this.setState({
+      Component,
+      componentNotFound: !Component
+    });
+  }
+  log(callbackArgs) {
+    if (this.debug) {
+      let args = callbackArgs();
+      if (!Array.isArray(args)) args = [args];
+      console.log(...args);
+    }
+  }
+  render() {
+    const {
+      componentPathParts,
+      match,
+      newParams,
+      newRouteParts
+    } = this.tt;
+    const {
+      children,
+      component,
+      path
+    } = this.props;
+    const {
+      Component,
+      componentNotFound,
+      matches
+    } = this.s;
+    if (!matches || !this.hasSwitchMatch()) {
+      // Route isn't matching and shouldn't be rendered at all.
+      return null;
+    }
+    if (!Component && !children && !componentNotFound) {
+      // Route is matching but hasn't been loaded yet.
+      return /*#__PURE__*/React.createElement("div", null, "Loading ", component || this.props.componentPath || componentPathParts.join("/"));
+    }
+    if (!Component && !children && componentNotFound) {
+      // Don't render anything if the component couldn't be found.
+      return null;
+    }
+    return /*#__PURE__*/React.createElement(CurrentPathContext.Provider, {
+      value: componentPathParts
+    }, /*#__PURE__*/React.createElement(RouteContext.Provider, {
+      value: newRouteParts.join("/")
+    }, /*#__PURE__*/React.createElement(ParamsContext.Provider, {
+      value: newParams
+    }, /*#__PURE__*/React.createElement(Switch, {
+      name: `route-group-${path}`,
+      single: false
+    }, Component && /*#__PURE__*/React.createElement(Component, {
+      match: match
+    }), children))));
+  }
+}));
+export { RequireComponentContext, RouteContext, Switch, useParams };
+export default Route;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","createContext","useContext","useMemo","memo","PropTypes","propTypesExact","shapeComponent","Switch","CurrentSwitchContext","CurrentPathContext","ParamsContext","RequireComponentContext","RouteContext","useParams","Route","defaultProps","exact","fallback","includeInPath","propTypes","children","node","component","string","componentPath","bool","isRequired","onMatch","func","path","oneOfType","instanceOf","RegExp","match","newParams","pathParts","setup","props","pathsMatched","switchGroup","givenRoute","pathShown","s","debug","log","requireComponent","currentParams","currentPath","routeParts","split","newRouteParts","slice","length","concat","useStates","Component","componentNotFound","matches","loadMatches","hasSwitchMatch","loadComponent","pathId","p","tt","params","componentPathParts","JSON","stringify","pathPartIndex","pathPart","translatedPathPart","I18n","t","defaultValue","routePart","decodeURIComponent","startsWith","paramName","push","matchId","Object","assign","setInstance","setState","setPathMatched","actualComponentPath","join","componentImport","routeDefinition","default","error","console","callbackArgs","args","Array","isArray","render","React","createElement","Provider","value","name","single"],"sources":["../../src/router/route.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport {createContext, useContext, useMemo} from \"react\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport Switch, {CurrentSwitchContext} from \"./switch\"\n\nconst CurrentPathContext = createContext([])\nconst ParamsContext = createContext({})\nconst RequireComponentContext = createContext(null)\nconst RouteContext = createContext(null)\nconst useParams = () => useContext(ParamsContext)\n\nconst Route = memo(shapeComponent(class Route extends BaseComponent {\n  static defaultProps = {\n    exact: false,\n    fallback: false,\n    includeInPath: true\n  }\n\n  static propTypes = propTypesExact({\n    children: PropTypes.node,\n    component: PropTypes.string,\n    componentPath: PropTypes.string,\n    exact: PropTypes.bool.isRequired,\n    fallback: PropTypes.bool.isRequired,\n    includeInPath: PropTypes.bool.isRequired,\n    onMatch: PropTypes.func,\n    path: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(RegExp)])\n  })\n\n  match = null\n  newParams = null\n  pathParts = null\n\n  setup() {\n    const {path} = this.props\n    const {pathsMatched, switchGroup} = useContext(CurrentSwitchContext)\n    const givenRoute = useContext(RouteContext)\n    const {pathShown} = switchGroup.s\n\n    this.debug = false\n    this.log(() => ({givenRoute}))\n\n    this.requireComponent = useContext(RequireComponentContext)\n    this.currentParams = useContext(ParamsContext)\n    this.currentPath = useContext(CurrentPathContext)\n    this.switchGroup = switchGroup\n    this.routeParts = useMemo(() => givenRoute?.split(\"/\"), [path, givenRoute])\n    this.pathParts = useMemo(() => path?.split(\"/\"), [path])\n\n    this.newRouteParts = useMemo(\n      () => {\n        if (!path) {\n          if (givenRoute == \"\") {\n            return []\n          } else {\n            return this.routeParts\n          }\n        }\n\n        return this.routeParts.slice(this.pathParts.length, this.routeParts.length)\n      },\n      [givenRoute].concat(this.pathParts)\n    )\n\n    this.useStates({Component: null, componentNotFound: null, matches: false})\n\n    useMemo(() => {\n      this.loadMatches()\n    }, [givenRoute, path, pathsMatched])\n\n    useMemo(() => {\n      if (this.hasSwitchMatch() && !this.s.Component && this.s.matches) {\n        if (this.props.onMatch) {\n          this.props.onMatch()\n        }\n\n        if (!this.props.children && (this.props.path || this.props.component || this.props.componentPath)) {\n          this.loadComponent()\n        }\n      }\n    }, [path, pathShown, this.s.matches])\n  }\n\n  hasSwitchMatch = () => this.switchGroup.s.pathShown && this.switchGroup.s.pathShown == this.pathId()\n\n  pathId() {\n    const {fallback} = this.p\n    const {path} = this.props\n    let pathId\n\n    if (fallback) {\n      pathId = \"[FALLBACK]\"\n    } else if (!path) {\n      pathId = \"[PATH-EMPTY]\"\n    } else {\n      pathId = path\n    }\n\n    return pathId\n  }\n\n  loadMatches() {\n    const {newRouteParts} = this.tt\n    const {component, path} = this.props\n    const {exact, includeInPath, fallback} = this.p\n\n    let matches = true\n    const params = {}\n    const componentPathParts = [...this.currentPath]\n\n    this.log(() => [this.props.path, \"Start generating component paths\", JSON.stringify(componentPathParts)])\n\n    for (const pathPartIndex in this.pathParts) {\n      const pathPart = this.pathParts[pathPartIndex]\n      const translatedPathPart = I18n.t(`routes.${pathPart}`, {defaultValue: pathPart})\n\n      if (!(pathPartIndex in this.routeParts)) {\n        this.log(() => `No match for: ${pathPartIndex}`)\n        matches = false\n        break\n      }\n\n      const routePart = decodeURIComponent(this.routeParts[pathPartIndex])\n\n      if (pathPart.startsWith(\":\") && routePart) {\n        const paramName = pathPart.slice(1, pathPart.length)\n\n        params[paramName] = routePart\n      } else if (translatedPathPart != routePart) {\n        matches = false\n        break\n      } else if (!component && includeInPath) {\n        componentPathParts.push(pathPart)\n      }\n    }\n\n    if (exact && newRouteParts.length > 0) {\n      this.log(() => [\"Exact and more route parts\", {newRouteParts, pathParts: this.pathParts, routeParts: this.routeParts}])\n      matches = false\n    } else if (matches && path) {\n      matches = true\n    } else if (this.routeParts.length == 0) {\n      matches = true\n    }\n\n    const matchId = this.pathId()\n\n    if (!matches && fallback) {\n      matches = true\n    }\n\n    this.log(() => [this.props.path, \"End generating component paths\", JSON.stringify(componentPathParts), {matches}])\n\n    if (matches) {\n      if (component && includeInPath) {\n        componentPathParts.push(component)\n      }\n\n      const newParams = Object.assign({}, this.currentParams, params)\n\n      this.setInstance({componentPathParts, match: {params}, newParams})\n      this.setState({matches})\n      this.switchGroup?.setPathMatched(matchId, true)\n    } else {\n      this.setInstance({componentPathParts: null, match: null, newParams: null})\n      this.setState({matches})\n      this.switchGroup?.setPathMatched(matchId, false)\n    }\n  }\n\n  async loadComponent() {\n    const actualComponentPath = this.props.componentPath || this.tt.componentPathParts.join(\"/\")\n    let Component\n\n    this.log(() => [\"loadComponent\", {componentPath: this.props.componentPath, componentPathParts: this.componentPathParts, actualComponentPath}])\n\n    try {\n      const componentImport = await this.tt.requireComponent({routeDefinition: {component: actualComponentPath}})\n\n      Component = componentImport.default\n    } catch (error) {\n      console.error(`Couldn't find component: ${actualComponentPath}`)\n\n      throw error\n    }\n\n    this.setState({Component, componentNotFound: !Component})\n  }\n\n  log(callbackArgs) {\n    if (this.debug) {\n      let args = callbackArgs()\n\n      if (!Array.isArray(args)) args = [args]\n\n      console.log(...args)\n    }\n  }\n\n  render() {\n    const {componentPathParts, match, newParams, newRouteParts} = this.tt\n    const {children, component, path} = this.props\n    const {Component, componentNotFound, matches} = this.s\n\n    if (!matches || !this.hasSwitchMatch()) {\n      // Route isn't matching and shouldn't be rendered at all.\n      return null\n    }\n\n    if (!Component && !children && !componentNotFound) {\n      // Route is matching but hasn't been loaded yet.\n      return (\n        <div>\n          Loading {component || this.props.componentPath || componentPathParts.join(\"/\")}\n        </div>\n      )\n    }\n\n    if (!Component && !children && componentNotFound) {\n      // Don't render anything if the component couldn't be found.\n      return null\n    }\n\n    return (\n      <CurrentPathContext.Provider value={componentPathParts}>\n        <RouteContext.Provider value={newRouteParts.join(\"/\")}>\n          <ParamsContext.Provider value={newParams}>\n            <Switch name={`route-group-${path}`} single={false}>\n              {Component && <Component match={match} />}\n              {children}\n            </Switch>\n          </ParamsContext.Provider>\n        </RouteContext.Provider>\n      </CurrentPathContext.Provider>\n    )\n  }\n}))\n\nexport {RequireComponentContext, RouteContext, Switch, useParams}\nexport default Route\n"],"mappings":"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","ignoreList":[]}

package/build/router/switch.js

@@ -0,0 +1,72 @@
+import BaseComponent from "../base-component";
+import { createContext } from "react";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+const CurrentSwitchContext = /*#__PURE__*/createContext([]);
+const Switch = memo(shapeComponent(class Switch extends BaseComponent {
+  static defaultProps = {
+    name: "[no name]",
+    single: true
+  };
+  static propTypes = propTypesExact({
+    children: PropTypes.node,
+    name: PropTypes.string,
+    single: PropTypes.bool
+  });
+  pathsMatchedKeys = [];
+  setup() {
+    this.useStates({
+      lastUpdate: new Date(),
+      pathShown: undefined,
+      pathsMatched: {}
+    });
+  }
+  render() {
+    const {
+      pathShown,
+      pathsMatched
+    } = this.s;
+    return /*#__PURE__*/React.createElement(CurrentSwitchContext.Provider, {
+      value: {
+        pathShown,
+        pathsMatched,
+        switchGroup: this
+      }
+    }, this.props.children);
+  }
+  pathShown(pathsMatched) {
+    for (const pathMatched of this.tt.pathsMatchedKeys) {
+      const isPathMatched = pathsMatched[pathMatched];
+      if (isPathMatched) {
+        return pathMatched;
+      }
+    }
+  }
+  setPathMatched(path, matched) {
+    const {
+      pathsMatchedKeys
+    } = this.tt;
+    const {
+      pathsMatched
+    } = this.s;
+    if (!path) throw new Error("No 'path' given");
+    if (pathsMatched[path] == matched) return;
+    if (!pathsMatchedKeys.includes(path)) {
+      pathsMatchedKeys.push(path);
+    }
+    const newPathsMatched = {
+      ...this.s.pathsMatched
+    };
+    newPathsMatched[path] = matched;
+    this.setState({
+      lastUpdate: Math.random() + new Date().getTime(),
+      pathShown: this.pathShown(newPathsMatched),
+      pathsMatched: newPathsMatched
+    });
+  }
+}));
+export { CurrentSwitchContext };
+export default Switch;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/router.js

@@ -0,0 +1,57 @@
+import BaseComponent from "./base-component";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React, { memo } from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import { Suspense } from "react";
+import useRouter from "./use-router";
+export default /*#__PURE__*/memo(shapeComponent(class ApiMakerRouter extends BaseComponent {
+  static propTypes = propTypesExact({
+    history: PropTypes.object,
+    notFoundComponent: PropTypes.elementType,
+    path: PropTypes.string,
+    requireComponent: PropTypes.func.isRequired,
+    routeDefinitions: PropTypes.object,
+    routes: PropTypes.object
+  });
+  render() {
+    const {
+      notFoundComponent,
+      path,
+      requireComponent,
+      routeDefinitions,
+      routes
+    } = this.props;
+    const {
+      match
+    } = useRouter({
+      path,
+      routes,
+      routeDefinitions
+    });
+    const {
+      matchingRoute
+    } = match;
+    if (!matchingRoute) {
+      if (notFoundComponent) {
+        const NotFoundComponent = notFoundComponent;
+        return /*#__PURE__*/React.createElement(Suspense, {
+          fallback: /*#__PURE__*/React.createElement("div", null)
+        }, /*#__PURE__*/React.createElement(NotFoundComponent, {
+          match: match
+        }));
+      } else {
+        return null;
+      }
+    }
+    const Component = requireComponent({
+      routeDefinition: matchingRoute.parsedRouteDefinition.routeDefinition
+    });
+    return /*#__PURE__*/React.createElement(Suspense, {
+      fallback: /*#__PURE__*/React.createElement("div", null)
+    }, /*#__PURE__*/React.createElement(Component, {
+      match: match
+    }));
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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