@kaspernj/api-maker 1.0.2011 → 1.0.2012

package/build/use-can-can.js

@@ -0,0 +1,55 @@
+import CanCan from "./can-can";
+import { useCallback, useMemo, useState } from "react";
+import useCurrentUser from "./use-current-user";
+import useEventEmitter from "./use-event-emitter";
+import useShape from "set-state-compare/src/use-shape";
+const useCanCan = (abilitiesCallback, dependencies) => {
+  const currentUser = useCurrentUser();
+  const s = useShape({
+    abilitiesCallback
+  });
+  s.useStates({
+    canCan: null,
+    lastUpdate: new Date()
+  });
+  if (!dependencies) {
+    dependencies = [currentUser?.id()];
+  }
+  const loadAbilities = useCallback(async () => {
+    const canCan = CanCan.current();
+    const abilities = s.p.abilitiesCallback();
+    await canCan.loadAbilities(abilities);
+    s.set({
+      canCan,
+      lastUpdate: new Date()
+    });
+  }, []);
+  const onResetAbilities = useCallback(async () => {
+    s.set({
+      canCan: null
+    }, {
+      silent: true
+    });
+    await loadAbilities();
+  }, []);
+  const loadAbilitiesOnNew = useCallback(async () => {
+    const canCan = s.s.canCan;
+    s.set({
+      canCan: null
+    }, {
+      silent: true
+    });
+    if (canCan) {
+      await canCan?.resetAbilities();
+    } else {
+      await loadAbilities();
+    }
+  }, []);
+  useMemo(() => {
+    loadAbilitiesOnNew();
+  }, dependencies);
+  useEventEmitter(CanCan.current().events, "onResetAbilities", onResetAbilities);
+  return s.s.canCan;
+};
+export default useCanCan;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/use-collection.js

@@ -0,0 +1,225 @@
+import debounce from "debounce";
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import ModelEvents from "./model-events";
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import useCreatedEvent from "./use-created-event";
+import useShape from "set-state-compare/src/use-shape";
+import useQueryParams from "on-location-changed/build/use-query-params";
+const useCollection = (props, cacheKeys = []) => {
+  const {
+    abilities,
+    collection,
+    defaultParams,
+    groupBy,
+    ifCondition,
+    limit,
+    modelClass,
+    noRecordsAvailableContent = undefined,
+    noRecordsFoundContent = undefined,
+    onModelsLoaded,
+    pagination = false,
+    preloads = [],
+    queryMethod,
+    queryName: initialQueryName,
+    ransack,
+    select = {},
+    selectColumns,
+    ...restProps
+  } = props;
+  if (Object.keys(restProps).length > 0) {
+    throw new Error(`Unknown props given to useCollection: ${Object.keys(restProps).join(", ")}`);
+  }
+  const s = useShape(props);
+  const queryName = initialQueryName || digg(modelClass.modelClassData(), "collectionKey");
+  s.meta.queryParams = useQueryParams();
+  const hasQParams = useCallback(() => {
+    if (s.s.queryQName in s.m.queryParams) return true;
+    return false;
+  }, []);
+  const qParams = useCallback(() => {
+    if (hasQParams()) return JSON.parse(digg(s.m.queryParams, s.s.queryQName));
+    return {};
+  }, []);
+  s.useStates({
+    models: undefined,
+    overallCount: undefined,
+    query: undefined,
+    queryName,
+    queryPerKey: `${queryName}_per`,
+    queryQName: `${queryName}_q`,
+    querySName: `${queryName}_s`,
+    queryPageName: `${queryName}_page`,
+    result: undefined,
+    searchParams: undefined,
+    showNoRecordsAvailableContent: false,
+    showNoRecordsFoundContent: false
+  });
+  s.useStates({
+    qParams: () => qParams()
+  });
+  let modelIdsCacheString;
+  if (s.s.models === undefined) {
+    modelIdsCacheString = "models-undefined";
+  } else if (s.s.models.length === 0) {
+    modelIdsCacheString = "no-models";
+  } else {
+    modelIdsCacheString = s.s.models.map(model => model.cacheKey())?.join("---");
+  }
+  const loadOverallCount = useCallback(async () => {
+    const baseQuery = s.p.collection || s.p.modelClass.all();
+    const overallCount = await baseQuery.count();
+    s.set({
+      overallCount,
+      showNoRecordsAvailableContent: showNoRecordsAvailableContent({
+        overallCount
+      }),
+      showNoRecordsFoundContent: showNoRecordsFoundContent({
+        overallCount
+      })
+    });
+  }, []);
+  const loadQParams = useCallback(() => {
+    const qParamsToSet = hasQParams() ? qParams() : Object.assign({}, s.props.defaultParams);
+    const searchParams = [];
+    if (s.m.queryParams[s.s.querySName]) {
+      for (const rawSearchParam of s.m.queryParams[s.s.querySName]) {
+        const parsedSearchParam = JSON.parse(rawSearchParam);
+        searchParams.push(parsedSearchParam);
+      }
+    }
+    s.set({
+      qParams: qParamsToSet,
+      searchParams
+    });
+  }, []);
+  const loadModels = useCallback(async () => {
+    let query = s.props.collection?.clone() || s.p.modelClass.ransack();
+    if (s.props.pagination) {
+      const page = s.m.queryParams[s.s.queryPageName] || 1;
+      let per = s.m.queryParams[s.s.queryPerKey] || 30;
+      if (per == "all") {
+        per = 999_999_999;
+      } else {
+        per = Number(per);
+      }
+      query.page(page).per(per);
+    }
+    if (s.props.groupBy) query = query.groupBy(...s.p.groupBy);
+    query = query.ransack(s.s.qParams).search(s.s.searchParams).searchKey(s.s.queryQName).pageKey(s.s.queryPageName).perKey(s.s.queryPerKey);
+    if (s.props.abilities) query.abilities(s.p.abilities);
+    if (s.props.limit !== undefined) query.limit(s.p.limit);
+    if (s.props.preloads) query.preload(s.p.preloads);
+    if (s.props.ransack) query.ransack(s.props.ransack);
+    if (s.props.select) query.select(s.p.select);
+    if (s.props.selectColumns) query.selectColumns(s.p.selectColumns);
+    let result;
+    if (s.props.queryMethod) {
+      result = await s.p.queryMethod({
+        query
+      });
+    } else {
+      result = await query.result();
+    }
+    const models = result.models();
+    if (s.props.onModelsLoaded) {
+      s.p.onModelsLoaded({
+        models,
+        qParams: s.s.qParams,
+        query,
+        result
+      });
+    }
+    s.set({
+      models: result.models(),
+      query,
+      result,
+      showNoRecordsAvailableContent: showNoRecordsAvailableContent({
+        models
+      }),
+      showNoRecordsFoundContent: showNoRecordsFoundContent({
+        models
+      })
+    });
+  }, []);
+  const loadModelsDebounce = useCallback(debounce(loadModels), []);
+  const onModelDestroyed = useCallback(args => {
+    s.set({
+      models: s.s.models.filter(model => model.id() != args.model.id())
+    });
+  }, []);
+  const onModelUpdated = useCallback(args => {
+    const updatedModel = digg(args, "model");
+    const foundModel = s.s.models.find(model => model.id() == updatedModel.id());
+    if (foundModel) loadModelsDebounce();
+  }, []);
+  const showNoRecordsAvailableContent = useCallback(args => {
+    let models, overallCount;
+    if (args.models !== undefined) {
+      models = args.models;
+    } else if (s.s.models !== undefined) {
+      models = s.s.models;
+    }
+    if (args.overallCount !== undefined) {
+      overallCount = args.overallCount;
+    } else if (s.s.overallCount !== undefined) {
+      overallCount = s.s.overallCount;
+    }
+    if (models === undefined || overallCount === undefined || s.p.noRecordsAvailableContent === undefined) return false;
+    if (models.length === 0 && overallCount === 0 && s.p.noRecordsAvailableContent) return true;
+  }, []);
+  const showNoRecordsFoundContent = useCallback(args => {
+    let models, overallCount;
+    if (args.models !== undefined) {
+      models = args.models;
+    } else if (s.s.models !== undefined) {
+      models = s.s.models;
+    }
+    if (args.overallCount !== undefined) {
+      overallCount = args.overallCount;
+    } else if (s.s.overallCount !== undefined) {
+      overallCount = s.s.overallCount;
+    }
+    if (models === undefined || s.props.noRecordsFoundContent === undefined) return false;
+
+    // Dont show noRecordsAvailableContent together with noRecordsAvailableContent
+    if (models.length === 0 && overallCount === 0 && s.props.noRecordsAvailableContent) return false;
+    if (models.length === 0 && s.props.noRecordsFoundContent) return true;
+  }, []);
+  const onCreated = useCallback(() => {
+    loadModels();
+  }, []);
+  useMemo(() => {
+    if (!("ifCondition" in s.props) || s.props.ifCondition) {
+      loadQParams();
+      loadModels();
+    }
+  }, [s.props.ifCondition, s.m.queryParams[s.s.queryQName], s.m.queryParams[s.s.queryPageName], s.m.queryParams[s.s.queryPerKey], s.m.queryParams[s.s.querySName], collection].concat(cacheKeys));
+  useMemo(() => {
+    if (s.props.noRecordsAvailableContent) {
+      loadOverallCount();
+    }
+  }, []);
+  useCreatedEvent(s.p.modelClass, onCreated);
+  useLayoutEffect(() => {
+    const connections = [];
+    if (s.s.models) {
+      for (const model of s.s.models) {
+        connections.push(ModelEvents.connectUpdated(model, onModelUpdated));
+        connections.push(ModelEvents.connectDestroyed(model, onModelDestroyed));
+      }
+    }
+    return () => {
+      for (const connection of connections) {
+        connection.unsubscribe();
+      }
+    };
+  }, [modelIdsCacheString]);
+  const result = Object.assign({}, s.state);
+  const modelVariableName = inflection.pluralize(inflection.camelize(modelClass.modelClassData().name, true));
+  result.modelIdsCacheString = modelIdsCacheString;
+  result[modelVariableName] = s.s.models;
+  return result;
+};
+export default useCollection;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["debounce","digg","inflection","ModelEvents","useCallback","useLayoutEffect","useMemo","useCreatedEvent","useShape","useQueryParams","useCollection","props","cacheKeys","abilities","collection","defaultParams","groupBy","ifCondition","limit","modelClass","noRecordsAvailableContent","undefined","noRecordsFoundContent","onModelsLoaded","pagination","preloads","queryMethod","queryName","initialQueryName","ransack","select","selectColumns","restProps","Object","keys","length","Error","join","s","modelClassData","meta","queryParams","hasQParams","queryQName","m","qParams","JSON","parse","useStates","models","overallCount","query","queryPerKey","querySName","queryPageName","result","searchParams","showNoRecordsAvailableContent","showNoRecordsFoundContent","modelIdsCacheString","map","model","cacheKey","loadOverallCount","baseQuery","p","all","count","set","loadQParams","qParamsToSet","assign","rawSearchParam","parsedSearchParam","push","loadModels","clone","page","per","Number","search","searchKey","pageKey","perKey","preload","loadModelsDebounce","onModelDestroyed","args","filter","id","onModelUpdated","updatedModel","foundModel","find","onCreated","concat","connections","connectUpdated","connectDestroyed","connection","unsubscribe","state","modelVariableName","pluralize","camelize","name"],"sources":["../src/use-collection.js"],"sourcesContent":["import debounce from \"debounce\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport ModelEvents from \"./model-events\"\nimport {useCallback, useLayoutEffect, useMemo} from \"react\"\nimport useCreatedEvent from \"./use-created-event\"\nimport useShape from \"set-state-compare/src/use-shape\"\nimport useQueryParams from \"on-location-changed/build/use-query-params\"\n\nconst useCollection = (props, cacheKeys = []) => {\n  const {\n    abilities,\n    collection,\n    defaultParams,\n    groupBy,\n    ifCondition,\n    limit,\n    modelClass,\n    noRecordsAvailableContent = undefined,\n    noRecordsFoundContent = undefined,\n    onModelsLoaded,\n    pagination = false,\n    preloads = [],\n    queryMethod,\n    queryName: initialQueryName,\n    ransack,\n    select = {},\n    selectColumns,\n    ...restProps\n  } = props\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to useCollection: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape(props)\n  const queryName = initialQueryName || digg(modelClass.modelClassData(), \"collectionKey\")\n\n  s.meta.queryParams = useQueryParams()\n\n  const hasQParams = useCallback(() => {\n    if (s.s.queryQName in s.m.queryParams) return true\n\n    return false\n  }, [])\n\n  const qParams = useCallback(() => {\n    if (hasQParams()) return JSON.parse(digg(s.m.queryParams, s.s.queryQName))\n\n    return {}\n  }, [])\n\n  s.useStates({\n    models: undefined,\n    overallCount: undefined,\n    query: undefined,\n    queryName,\n    queryPerKey: `${queryName}_per`,\n    queryQName: `${queryName}_q`,\n    querySName: `${queryName}_s`,\n    queryPageName: `${queryName}_page`,\n    result: undefined,\n    searchParams: undefined,\n    showNoRecordsAvailableContent: false,\n    showNoRecordsFoundContent: false\n  })\n  s.useStates({\n    qParams: () => qParams()\n  })\n\n  let modelIdsCacheString\n\n  if (s.s.models === undefined) {\n    modelIdsCacheString = \"models-undefined\"\n  } else if (s.s.models.length === 0) {\n    modelIdsCacheString = \"no-models\"\n  } else {\n    modelIdsCacheString = s.s.models.map((model) => model.cacheKey())?.join(\"---\")\n  }\n\n  const loadOverallCount = useCallback(async () => {\n    const baseQuery = s.p.collection || s.p.modelClass.all()\n    const overallCount = await baseQuery.count()\n\n    s.set({\n      overallCount,\n      showNoRecordsAvailableContent: showNoRecordsAvailableContent({overallCount}),\n      showNoRecordsFoundContent: showNoRecordsFoundContent({overallCount})\n    })\n  }, [])\n\n  const loadQParams = useCallback(() => {\n    const qParamsToSet = hasQParams() ? qParams() : Object.assign({}, s.props.defaultParams)\n    const searchParams = []\n\n    if (s.m.queryParams[s.s.querySName]) {\n      for (const rawSearchParam of s.m.queryParams[s.s.querySName]) {\n        const parsedSearchParam = JSON.parse(rawSearchParam)\n\n        searchParams.push(parsedSearchParam)\n      }\n    }\n\n    s.set({\n      qParams: qParamsToSet,\n      searchParams\n    })\n  }, [])\n\n  const loadModels = useCallback(async () => {\n    let query = s.props.collection?.clone() || s.p.modelClass.ransack()\n\n    if (s.props.pagination) {\n      const page = s.m.queryParams[s.s.queryPageName] || 1\n      let per = s.m.queryParams[s.s.queryPerKey] || 30\n\n      if (per == \"all\") {\n        per = 999_999_999\n      } else {\n        per = Number(per)\n      }\n\n      query.page(page).per(per)\n    }\n\n    if (s.props.groupBy) query = query.groupBy(...s.p.groupBy)\n\n    query = query\n      .ransack(s.s.qParams)\n      .search(s.s.searchParams)\n      .searchKey(s.s.queryQName)\n      .pageKey(s.s.queryPageName)\n      .perKey(s.s.queryPerKey)\n\n    if (s.props.abilities) query.abilities(s.p.abilities)\n    if (s.props.limit !== undefined) query.limit(s.p.limit)\n    if (s.props.preloads) query.preload(s.p.preloads)\n    if (s.props.ransack) query.ransack(s.props.ransack)\n    if (s.props.select) query.select(s.p.select)\n    if (s.props.selectColumns) query.selectColumns(s.p.selectColumns)\n\n    let result\n\n    if (s.props.queryMethod) {\n      result = await s.p.queryMethod({query})\n    } else {\n      result = await query.result()\n    }\n\n    const models = result.models()\n\n    if (s.props.onModelsLoaded) {\n      s.p.onModelsLoaded({\n        models,\n        qParams: s.s.qParams,\n        query,\n        result\n      })\n    }\n\n    s.set({\n      models: result.models(),\n      query,\n      result,\n      showNoRecordsAvailableContent: showNoRecordsAvailableContent({models}),\n      showNoRecordsFoundContent: showNoRecordsFoundContent({models})\n    })\n  }, [])\n\n  const loadModelsDebounce = useCallback(debounce(loadModels), [])\n  const onModelDestroyed = useCallback((args) => {\n    s.set({\n      models: s.s.models.filter((model) => model.id() != args.model.id())\n    })\n  }, [])\n\n  const onModelUpdated = useCallback((args) => {\n    const updatedModel = digg(args, \"model\")\n    const foundModel = s.s.models.find((model) => model.id() == updatedModel.id())\n\n    if (foundModel) loadModelsDebounce()\n  }, [])\n\n  const showNoRecordsAvailableContent = useCallback((args) => {\n    let models, overallCount\n\n    if (args.models !== undefined) {\n      models = args.models\n    } else if (s.s.models !== undefined) {\n      models = s.s.models\n    }\n\n    if (args.overallCount !== undefined) {\n      overallCount = args.overallCount\n    } else if (s.s.overallCount !== undefined) {\n      overallCount = s.s.overallCount\n    }\n\n    if (models === undefined || overallCount === undefined || s.p.noRecordsAvailableContent === undefined) return false\n    if (models.length === 0 && overallCount === 0 && s.p.noRecordsAvailableContent) return true\n  }, [])\n\n  const showNoRecordsFoundContent = useCallback((args) => {\n    let models, overallCount\n\n    if (args.models !== undefined) {\n      models = args.models\n    } else if (s.s.models !== undefined) {\n      models = s.s.models\n    }\n\n    if (args.overallCount !== undefined) {\n      overallCount = args.overallCount\n    } else if (s.s.overallCount !== undefined) {\n      overallCount = s.s.overallCount\n    }\n\n    if (models === undefined || s.props.noRecordsFoundContent === undefined) return false\n\n    // Dont show noRecordsAvailableContent together with noRecordsAvailableContent\n    if (models.length === 0 && overallCount === 0 && s.props.noRecordsAvailableContent) return false\n    if (models.length === 0 && s.props.noRecordsFoundContent) return true\n  }, [])\n\n  const onCreated = useCallback(() => {\n    loadModels()\n  }, [])\n\n  useMemo(\n    () => {\n      if (!(\"ifCondition\" in s.props) || s.props.ifCondition) {\n        loadQParams()\n        loadModels()\n      }\n    },\n    [\n      s.props.ifCondition,\n      s.m.queryParams[s.s.queryQName],\n      s.m.queryParams[s.s.queryPageName],\n      s.m.queryParams[s.s.queryPerKey],\n      s.m.queryParams[s.s.querySName],\n      collection\n    ].concat(cacheKeys)\n  )\n\n  useMemo(() => {\n    if (s.props.noRecordsAvailableContent) {\n      loadOverallCount()\n    }\n  }, [])\n\n  useCreatedEvent(s.p.modelClass, onCreated)\n\n  useLayoutEffect(() => {\n    const connections = []\n\n    if (s.s.models) {\n      for(const model of s.s.models) {\n        connections.push(ModelEvents.connectUpdated(model, onModelUpdated))\n        connections.push(ModelEvents.connectDestroyed(model, onModelDestroyed))\n      }\n    }\n\n    return () => {\n      for(const connection of connections) {\n        connection.unsubscribe()\n      }\n    }\n  }, [modelIdsCacheString])\n\n  const result = Object.assign({}, s.state)\n  const modelVariableName = inflection.pluralize(inflection.camelize(modelClass.modelClassData().name, true))\n\n  result.modelIdsCacheString = modelIdsCacheString\n  result[modelVariableName] = s.s.models\n\n  return result\n}\n\nexport default useCollection\n"],"mappings":"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","ignoreList":[]}

package/build/use-created-event.js

@@ -0,0 +1,52 @@
+import debounceFunction from "debounce";
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import { useCallback, useLayoutEffect } from "react";
+import useShape from "set-state-compare/src/use-shape";
+const ApiMakerUseCreatedEvent = (modelClass, onCreated, args = {}) => {
+  const {
+    active = true,
+    debounce
+  } = args;
+  const s = useShape({
+    active,
+    debounce,
+    modelClass,
+    onCreated
+  });
+  const eventDebounce = useCallback(() => {
+    if (!s.meta.debounceInstance) {
+      if (typeof this.props.debounce == "number") {
+        s.meta.debounceInstance = debounceFunction(s.p.onCreated, s.p.debounce);
+      } else {
+        s.meta.debounceInstance = debounceFunction(s.p.onCreated);
+      }
+    }
+    return s.meta.debounceInstance;
+  }, []);
+  const onCreatedCallback = useCallback((...args) => {
+    if (!s.p.active) {
+      return;
+    }
+    if (s.p.debounce) {
+      eventDebounce()(...args);
+    } else {
+      s.p.onCreated(...args);
+    }
+  }, []);
+  useLayoutEffect(() => {
+    const connectCreated = ModelEvents.connectCreated(s.p.modelClass, (...args) => onCreatedCallback(...args));
+    return () => {
+      connectCreated.unsubscribe();
+    };
+  }, []);
+};
+ApiMakerUseCreatedEvent.propTypes = propTypesExact({
+  active: PropTypes.bool.isRequired,
+  debounce: PropTypes.oneOfType([PropTypes.bool, PropTypes.number]),
+  modelClass: PropTypes.func.isRequired,
+  onCreated: PropTypes.func.isRequired
+});
+export default ApiMakerUseCreatedEvent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWJvdW5jZUZ1bmN0aW9uIiwiTW9kZWxFdmVudHMiLCJQcm9wVHlwZXMiLCJwcm9wVHlwZXNFeGFjdCIsInVzZUNhbGxiYWNrIiwidXNlTGF5b3V0RWZmZWN0IiwidXNlU2hhcGUiLCJBcGlNYWtlclVzZUNyZWF0ZWRFdmVudCIsIm1vZGVsQ2xhc3MiLCJvbkNyZWF0ZWQiLCJhcmdzIiwiYWN0aXZlIiwiZGVib3VuY2UiLCJzIiwiZXZlbnREZWJvdW5jZSIsIm1ldGEiLCJkZWJvdW5jZUluc3RhbmNlIiwicHJvcHMiLCJwIiwib25DcmVhdGVkQ2FsbGJhY2siLCJjb25uZWN0Q3JlYXRlZCIsInVuc3Vic2NyaWJlIiwicHJvcFR5cGVzIiwiYm9vbCIsImlzUmVxdWlyZWQiLCJvbmVPZlR5cGUiLCJudW1iZXIiLCJmdW5jIl0sInNvdXJjZXMiOlsiLi4vc3JjL3VzZS1jcmVhdGVkLWV2ZW50LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkZWJvdW5jZUZ1bmN0aW9uIGZyb20gXCJkZWJvdW5jZVwiXG5pbXBvcnQgTW9kZWxFdmVudHMgZnJvbSBcIi4vbW9kZWwtZXZlbnRzXCJcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSBcInByb3AtdHlwZXNcIlxuaW1wb3J0IHByb3BUeXBlc0V4YWN0IGZyb20gXCJwcm9wLXR5cGVzLWV4YWN0XCJcbmltcG9ydCB7dXNlQ2FsbGJhY2ssIHVzZUxheW91dEVmZmVjdH0gZnJvbSBcInJlYWN0XCJcbmltcG9ydCB1c2VTaGFwZSBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL3VzZS1zaGFwZVwiXG5cbmNvbnN0IEFwaU1ha2VyVXNlQ3JlYXRlZEV2ZW50ID0gKG1vZGVsQ2xhc3MsIG9uQ3JlYXRlZCwgYXJncyA9IHt9KSA9PiB7XG4gIGNvbnN0IHthY3RpdmUgPSB0cnVlLCBkZWJvdW5jZX0gPSBhcmdzXG4gIGNvbnN0IHMgPSB1c2VTaGFwZSh7YWN0aXZlLCBkZWJvdW5jZSwgbW9kZWxDbGFzcywgb25DcmVhdGVkfSlcblxuICBjb25zdCBldmVudERlYm91bmNlID0gdXNlQ2FsbGJhY2soKCkgPT4ge1xuICAgIGlmICghcy5tZXRhLmRlYm91bmNlSW5zdGFuY2UpIHtcbiAgICAgIGlmICh0eXBlb2YgdGhpcy5wcm9wcy5kZWJvdW5jZSA9PSBcIm51bWJlclwiKSB7XG4gICAgICAgIHMubWV0YS5kZWJvdW5jZUluc3RhbmNlID0gZGVib3VuY2VGdW5jdGlvbihzLnAub25DcmVhdGVkLCBzLnAuZGVib3VuY2UpXG4gICAgICB9IGVsc2Uge1xuICAgICAgICBzLm1ldGEuZGVib3VuY2VJbnN0YW5jZSA9IGRlYm91bmNlRnVuY3Rpb24ocy5wLm9uQ3JlYXRlZClcbiAgICAgIH1cbiAgICB9XG5cbiAgICByZXR1cm4gcy5tZXRhLmRlYm91bmNlSW5zdGFuY2VcbiAgfSwgW10pXG5cbiAgY29uc3Qgb25DcmVhdGVkQ2FsbGJhY2sgPSB1c2VDYWxsYmFjaygoLi4uYXJncykgPT4ge1xuICAgIGlmICghcy5wLmFjdGl2ZSkge1xuICAgICAgcmV0dXJuXG4gICAgfVxuXG4gICAgaWYgKHMucC5kZWJvdW5jZSkge1xuICAgICAgZXZlbnREZWJvdW5jZSgpKC4uLmFyZ3MpXG4gICAgfSBlbHNlIHtcbiAgICAgIHMucC5vbkNyZWF0ZWQoLi4uYXJncylcbiAgICB9XG4gIH0sIFtdKVxuXG4gIHVzZUxheW91dEVmZmVjdCgoKSA9PiB7XG4gICAgY29uc3QgY29ubmVjdENyZWF0ZWQgPSBNb2RlbEV2ZW50cy5jb25uZWN0Q3JlYXRlZChzLnAubW9kZWxDbGFzcywgKC4uLmFyZ3MpID0+IG9uQ3JlYXRlZENhbGxiYWNrKC4uLmFyZ3MpKVxuXG4gICAgcmV0dXJuICgpID0+IHtcbiAgICAgIGNvbm5lY3RDcmVhdGVkLnVuc3Vic2NyaWJlKClcbiAgICB9XG4gIH0sIFtdKVxufVxuXG5BcGlNYWtlclVzZUNyZWF0ZWRFdmVudC5wcm9wVHlwZXMgPSBwcm9wVHlwZXNFeGFjdCh7XG4gIGFjdGl2ZTogUHJvcFR5cGVzLmJvb2wuaXNSZXF1aXJlZCxcbiAgZGVib3VuY2U6IFByb3BUeXBlcy5vbmVPZlR5cGUoW1xuICAgIFByb3BUeXBlcy5ib29sLFxuICAgIFByb3BUeXBlcy5udW1iZXJcbiAgXSksXG4gIG1vZGVsQ2xhc3M6IFByb3BUeXBlcy5mdW5jLmlzUmVxdWlyZWQsXG4gIG9uQ3JlYXRlZDogUHJvcFR5cGVzLmZ1bmMuaXNSZXF1aXJlZFxufSlcblxuZXhwb3J0IGRlZmF1bHQgQXBpTWFrZXJVc2VDcmVhdGVkRXZlbnRcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsZ0JBQWdCLE1BQU0sVUFBVTtBQUN2QyxPQUFPQyxXQUFXLE1BQU0sZ0JBQWdCO0FBQ3hDLE9BQU9DLFNBQVMsTUFBTSxZQUFZO0FBQ2xDLE9BQU9DLGNBQWMsTUFBTSxrQkFBa0I7QUFDN0MsU0FBUUMsV0FBVyxFQUFFQyxlQUFlLFFBQU8sT0FBTztBQUNsRCxPQUFPQyxRQUFRLE1BQU0saUNBQWlDO0FBRXRELE1BQU1DLHVCQUF1QixHQUFHQSxDQUFDQyxVQUFVLEVBQUVDLFNBQVMsRUFBRUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxLQUFLO0VBQ3BFLE1BQU07SUFBQ0MsTUFBTSxHQUFHLElBQUk7SUFBRUM7RUFBUSxDQUFDLEdBQUdGLElBQUk7RUFDdEMsTUFBTUcsQ0FBQyxHQUFHUCxRQUFRLENBQUM7SUFBQ0ssTUFBTTtJQUFFQyxRQUFRO0lBQUVKLFVBQVU7SUFBRUM7RUFBUyxDQUFDLENBQUM7RUFFN0QsTUFBTUssYUFBYSxHQUFHVixXQUFXLENBQUMsTUFBTTtJQUN0QyxJQUFJLENBQUNTLENBQUMsQ0FBQ0UsSUFBSSxDQUFDQyxnQkFBZ0IsRUFBRTtNQUM1QixJQUFJLE9BQU8sSUFBSSxDQUFDQyxLQUFLLENBQUNMLFFBQVEsSUFBSSxRQUFRLEVBQUU7UUFDMUNDLENBQUMsQ0FBQ0UsSUFBSSxDQUFDQyxnQkFBZ0IsR0FBR2hCLGdCQUFnQixDQUFDYSxDQUFDLENBQUNLLENBQUMsQ0FBQ1QsU0FBUyxFQUFFSSxDQUFDLENBQUNLLENBQUMsQ0FBQ04sUUFBUSxDQUFDO01BQ3pFLENBQUMsTUFBTTtRQUNMQyxDQUFDLENBQUNFLElBQUksQ0FBQ0MsZ0JBQWdCLEdBQUdoQixnQkFBZ0IsQ0FBQ2EsQ0FBQyxDQUFDSyxDQUFDLENBQUNULFNBQVMsQ0FBQztNQUMzRDtJQUNGO0lBRUEsT0FBT0ksQ0FBQyxDQUFDRSxJQUFJLENBQUNDLGdCQUFnQjtFQUNoQyxDQUFDLEVBQUUsRUFBRSxDQUFDO0VBRU4sTUFBTUcsaUJBQWlCLEdBQUdmLFdBQVcsQ0FBQyxDQUFDLEdBQUdNLElBQUksS0FBSztJQUNqRCxJQUFJLENBQUNHLENBQUMsQ0FBQ0ssQ0FBQyxDQUFDUCxNQUFNLEVBQUU7TUFDZjtJQUNGO0lBRUEsSUFBSUUsQ0FBQyxDQUFDSyxDQUFDLENBQUNOLFFBQVEsRUFBRTtNQUNoQkUsYUFBYSxDQUFDLENBQUMsQ0FBQyxHQUFHSixJQUFJLENBQUM7SUFDMUIsQ0FBQyxNQUFNO01BQ0xHLENBQUMsQ0FBQ0ssQ0FBQyxDQUFDVCxTQUFTLENBQUMsR0FBR0MsSUFBSSxDQUFDO0lBQ3hCO0VBQ0YsQ0FBQyxFQUFFLEVBQUUsQ0FBQztFQUVOTCxlQUFlLENBQUMsTUFBTTtJQUNwQixNQUFNZSxjQUFjLEdBQUduQixXQUFXLENBQUNtQixjQUFjLENBQUNQLENBQUMsQ0FBQ0ssQ0FBQyxDQUFDVixVQUFVLEVBQUUsQ0FBQyxHQUFHRSxJQUFJLEtBQUtTLGlCQUFpQixDQUFDLEdBQUdULElBQUksQ0FBQyxDQUFDO0lBRTFHLE9BQU8sTUFBTTtNQUNYVSxjQUFjLENBQUNDLFdBQVcsQ0FBQyxDQUFDO0lBQzlCLENBQUM7RUFDSCxDQUFDLEVBQUUsRUFBRSxDQUFDO0FBQ1IsQ0FBQztBQUVEZCx1QkFBdUIsQ0FBQ2UsU0FBUyxHQUFHbkIsY0FBYyxDQUFDO0VBQ2pEUSxNQUFNLEVBQUVULFNBQVMsQ0FBQ3FCLElBQUksQ0FBQ0MsVUFBVTtFQUNqQ1osUUFBUSxFQUFFVixTQUFTLENBQUN1QixTQUFTLENBQUMsQ0FDNUJ2QixTQUFTLENBQUNxQixJQUFJLEVBQ2RyQixTQUFTLENBQUN3QixNQUFNLENBQ2pCLENBQUM7RUFDRmxCLFVBQVUsRUFBRU4sU0FBUyxDQUFDeUIsSUFBSSxDQUFDSCxVQUFVO0VBQ3JDZixTQUFTLEVBQUVQLFNBQVMsQ0FBQ3lCLElBQUksQ0FBQ0g7QUFDNUIsQ0FBQyxDQUFDO0FBRUYsZUFBZWpCLHVCQUF1QiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/use-current-user.js

@@ -0,0 +1,76 @@
+import { useCallback, useMemo } from "react";
+import Devise from "./devise";
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import Logger from "./logger";
+import Services from "./services";
+import useEventEmitter from "./use-event-emitter";
+import useShape from "set-state-compare/src/use-shape";
+const logger = new Logger({
+  name: "ApiMaker / useCurrentUser"
+});
+
+// logger.setDebug(true)
+
+const useCurrentUser = args => {
+  const s = useShape(args || {});
+  const scope = args?.scope || "user";
+  const scopeName = `current${inflection.camelize(scope)}`;
+  s.meta.scope = scope;
+  s.meta.scopeName = scopeName;
+  const loadCurrentUserFromRequest = useCallback(async () => {
+    const {
+      scope,
+      scopeName
+    } = s.m;
+    const getArgsMethodName = `get${inflection.camelize(scope)}Args`;
+    const args = Devise[getArgsMethodName]();
+    logger.debug(() => `Loading ${scope} with request`);
+    const result = await Services.current().sendRequest("Devise::Current", {
+      query: args.query,
+      scope
+    });
+    const current = digg(result, "current")[0];
+    if (!(scopeName in s.setStates)) throw new Error(`'${scopeName}' not found in setStates`);
+    if (current) Devise.updateSession(current);
+    s.setStates[scopeName](current);
+    if (s.props.onCurrentUserLoaded) setTimeout(() => s.props.onCurrentUserLoaded(current), 0);
+  }, []);
+  const defaultCurrentUser = useCallback(() => {
+    const {
+      scope,
+      scopeName
+    } = s.m;
+    let current;
+    if (Devise.current().hasCurrentScope(s.m.scope)) {
+      current = Devise.current().getCurrentScope(scope);
+      logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`);
+    } else if (Devise.current().hasGlobalCurrentScope(scope)) {
+      current = Devise[scopeName]();
+      logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`);
+    }
+    if (current && s.props.onCurrentUserLoaded) {
+      setTimeout(() => s.props.onCurrentUserLoaded(current), 0);
+    }
+    return current;
+  }, []);
+  const useStatesArgument = {};
+  useStatesArgument[scopeName] = () => defaultCurrentUser();
+  s.useStates(useStatesArgument);
+  const updateCurrentUser = useCallback(() => {
+    const setStatesArgument = {};
+    setStatesArgument[s.m.scopeName] = Devise[s.m.scopeName]();
+    s.set(setStatesArgument);
+  }, []);
+  useMemo(() => {
+    if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {
+      logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`);
+      loadCurrentUserFromRequest();
+    }
+  }, []);
+  useEventEmitter(Devise.events(), "onDeviseSignIn", updateCurrentUser);
+  useEventEmitter(Devise.events(), "onDeviseSignOut", updateCurrentUser);
+  return s.s[scopeName];
+};
+export default useCurrentUser;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useCallback","useMemo","Devise","digg","inflection","Logger","Services","useEventEmitter","useShape","logger","name","useCurrentUser","args","s","scope","scopeName","camelize","meta","loadCurrentUserFromRequest","m","getArgsMethodName","debug","result","current","sendRequest","query","setStates","Error","updateSession","props","onCurrentUserLoaded","setTimeout","defaultCurrentUser","hasCurrentScope","getCurrentScope","id","hasGlobalCurrentScope","useStatesArgument","useStates","updateCurrentUser","setStatesArgument","set","events"],"sources":["../src/use-current-user.js"],"sourcesContent":["import {useCallback, useMemo} from \"react\"\nimport Devise from \"./devise\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger\"\nimport Services from \"./services\"\nimport useEventEmitter from \"./use-event-emitter\"\nimport useShape from \"set-state-compare/src/use-shape\"\n\nconst logger = new Logger({name: \"ApiMaker / useCurrentUser\"})\n\n// logger.setDebug(true)\n\nconst useCurrentUser = (args) => {\n  const s = useShape(args || {})\n  const scope = args?.scope || \"user\"\n  const scopeName = `current${inflection.camelize(scope)}`\n\n  s.meta.scope = scope\n  s.meta.scopeName = scopeName\n\n  const loadCurrentUserFromRequest = useCallback(async () => {\n    const {scope, scopeName} = s.m\n    const getArgsMethodName = `get${inflection.camelize(scope)}Args`\n    const args = Devise[getArgsMethodName]()\n\n    logger.debug(() => `Loading ${scope} with request`)\n\n    const result = await Services.current().sendRequest(\"Devise::Current\", {query: args.query, scope})\n    const current = digg(result, \"current\")[0]\n\n    if (!(scopeName in s.setStates)) throw new Error(`'${scopeName}' not found in setStates`)\n    if (current) Devise.updateSession(current)\n\n    s.setStates[scopeName](current)\n\n    if (s.props.onCurrentUserLoaded) setTimeout(() => s.props.onCurrentUserLoaded(current), 0)\n  }, [])\n\n  const defaultCurrentUser = useCallback(() => {\n    const {scope, scopeName} = s.m\n    let current\n\n    if (Devise.current().hasCurrentScope(s.m.scope)) {\n      current = Devise.current().getCurrentScope(scope)\n\n      logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`)\n    } else if (Devise.current().hasGlobalCurrentScope(scope)) {\n      current = Devise[scopeName]()\n\n      logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`)\n    }\n\n    if (current && s.props.onCurrentUserLoaded) {\n      setTimeout(() => s.props.onCurrentUserLoaded(current), 0)\n    }\n\n    return current\n  }, [])\n\n  const useStatesArgument = {}\n\n  useStatesArgument[scopeName] = () => defaultCurrentUser()\n\n  s.useStates(useStatesArgument)\n\n  const updateCurrentUser = useCallback(() => {\n    const setStatesArgument = {}\n\n    setStatesArgument[s.m.scopeName] = Devise[s.m.scopeName]()\n\n    s.set(setStatesArgument)\n  }, [])\n\n  useMemo(() => {\n    if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {\n      logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`)\n      loadCurrentUserFromRequest()\n    }\n  }, [])\n\n  useEventEmitter(Devise.events(), \"onDeviseSignIn\", updateCurrentUser)\n  useEventEmitter(Devise.events(), \"onDeviseSignOut\", updateCurrentUser)\n\n  return s.s[scopeName]\n}\n\nexport default useCurrentUser\n"],"mappings":"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","ignoreList":[]}

package/build/use-destroyed-event.js

@@ -0,0 +1,60 @@
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import debounceFunction from "debounce";
+import ModelEvents from "./model-events";
+import useShape from "set-state-compare/src/use-shape";
+const apiMakerUseDestroyedEvent = (model, onDestroyed, props) => {
+  const {
+    active = true,
+    debounce,
+    onConnected,
+    ...restProps
+  } = props || {};
+  if (Object.keys(restProps).length > 0) {
+    throw new Error(`Unknown props given to useDestroyedEvent: ${Object.keys(restProps).join(", ")}`);
+  }
+  const s = useShape({
+    active,
+    debounce,
+    model,
+    onDestroyed
+  });
+  const debounceCallback = useMemo(() => {
+    if (typeof debounce == "number") {
+      return debounceFunction(s.p.onDestroyed, debounce);
+    } else {
+      return debounceFunction(s.p.onDestroyed);
+    }
+  }, [debounce]);
+  s.updateMeta({
+    debounceCallback
+  });
+  const onDestroyedCallback = useCallback((...args) => {
+    if (!s.p.active) {
+      return;
+    }
+    if (s.p.debounce) {
+      s.m.debounceCallback(...args);
+    } else {
+      s.p.onDestroyed(...args);
+    }
+  }, []);
+  useLayoutEffect(() => {
+    let connectDestroyed, onConnectedListener;
+    if (model) {
+      connectDestroyed = ModelEvents.connectDestroyed(model, onDestroyedCallback);
+      if (onConnected) {
+        onConnectedListener = connectDestroyed.events.addListener("connected", onConnected);
+      }
+    }
+    return () => {
+      if (onConnectedListener) {
+        connectDestroyed.events.removeListener("connected", onConnected);
+      }
+      if (connectDestroyed) {
+        connectDestroyed.unsubscribe();
+      }
+    };
+  }, [model?.id()]);
+};
+export default apiMakerUseDestroyedEvent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/use-event-emitter.js

@@ -0,0 +1,13 @@
+import { useLayoutEffect } from "react";
+const ApiMakerUseEventEmitter = (events, event, onCalled) => {
+  useLayoutEffect(() => {
+    if (events) {
+      events.addListener(event, onCalled);
+      return () => {
+        events.removeListener(event, onCalled);
+      };
+    }
+  }, [events, event, onCalled]);
+};
+export default ApiMakerUseEventEmitter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VMYXlvdXRFZmZlY3QiLCJBcGlNYWtlclVzZUV2ZW50RW1pdHRlciIsImV2ZW50cyIsImV2ZW50Iiwib25DYWxsZWQiLCJhZGRMaXN0ZW5lciIsInJlbW92ZUxpc3RlbmVyIl0sInNvdXJjZXMiOlsiLi4vc3JjL3VzZS1ldmVudC1lbWl0dGVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7dXNlTGF5b3V0RWZmZWN0fSBmcm9tIFwicmVhY3RcIlxuXG5jb25zdCBBcGlNYWtlclVzZUV2ZW50RW1pdHRlciA9IChldmVudHMsIGV2ZW50LCBvbkNhbGxlZCkgPT4ge1xuICB1c2VMYXlvdXRFZmZlY3QoKCkgPT4ge1xuICAgIGlmIChldmVudHMpIHtcbiAgICAgIGV2ZW50cy5hZGRMaXN0ZW5lcihldmVudCwgb25DYWxsZWQpXG5cbiAgICAgIHJldHVybiAoKSA9PiB7XG4gICAgICAgIGV2ZW50cy5yZW1vdmVMaXN0ZW5lcihldmVudCwgb25DYWxsZWQpXG4gICAgICB9XG4gICAgfVxuICB9LCBbZXZlbnRzLCBldmVudCwgb25DYWxsZWRdKVxufVxuXG5leHBvcnQgZGVmYXVsdCBBcGlNYWtlclVzZUV2ZW50RW1pdHRlclxuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFRQSxlQUFlLFFBQU8sT0FBTztBQUVyQyxNQUFNQyx1QkFBdUIsR0FBR0EsQ0FBQ0MsTUFBTSxFQUFFQyxLQUFLLEVBQUVDLFFBQVEsS0FBSztFQUMzREosZUFBZSxDQUFDLE1BQU07SUFDcEIsSUFBSUUsTUFBTSxFQUFFO01BQ1ZBLE1BQU0sQ0FBQ0csV0FBVyxDQUFDRixLQUFLLEVBQUVDLFFBQVEsQ0FBQztNQUVuQyxPQUFPLE1BQU07UUFDWEYsTUFBTSxDQUFDSSxjQUFjLENBQUNILEtBQUssRUFBRUMsUUFBUSxDQUFDO01BQ3hDLENBQUM7SUFDSDtFQUNGLENBQUMsRUFBRSxDQUFDRixNQUFNLEVBQUVDLEtBQUssRUFBRUMsUUFBUSxDQUFDLENBQUM7QUFDL0IsQ0FBQztBQUVELGVBQWVILHVCQUF1QiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/use-event-listener.js

@@ -0,0 +1,16 @@
+import { useCallback, useLayoutEffect } from "react";
+const ApiMakerUseEventListener = (target, event, onCalled) => {
+  const onCalledCallback = useCallback((...args) => {
+    onCalled.apply(null, args);
+  }, [target, event, onCalled]);
+  useLayoutEffect(() => {
+    if (target) {
+      target.addEventListener(event, onCalledCallback);
+      return () => {
+        target.removeEventListener(event, onCalledCallback);
+      };
+    }
+  }, [target, event, onCalled]);
+};
+export default ApiMakerUseEventListener;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VDYWxsYmFjayIsInVzZUxheW91dEVmZmVjdCIsIkFwaU1ha2VyVXNlRXZlbnRMaXN0ZW5lciIsInRhcmdldCIsImV2ZW50Iiwib25DYWxsZWQiLCJvbkNhbGxlZENhbGxiYWNrIiwiYXJncyIsImFwcGx5IiwiYWRkRXZlbnRMaXN0ZW5lciIsInJlbW92ZUV2ZW50TGlzdGVuZXIiXSwic291cmNlcyI6WyIuLi9zcmMvdXNlLWV2ZW50LWxpc3RlbmVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7dXNlQ2FsbGJhY2ssIHVzZUxheW91dEVmZmVjdH0gZnJvbSBcInJlYWN0XCJcblxuY29uc3QgQXBpTWFrZXJVc2VFdmVudExpc3RlbmVyID0gKHRhcmdldCwgZXZlbnQsIG9uQ2FsbGVkKSA9PiB7XG4gIGNvbnN0IG9uQ2FsbGVkQ2FsbGJhY2sgPSB1c2VDYWxsYmFjaygoLi4uYXJncykgPT4ge1xuICAgIG9uQ2FsbGVkLmFwcGx5KG51bGwsIGFyZ3MpXG4gIH0sIFt0YXJnZXQsIGV2ZW50LCBvbkNhbGxlZF0pXG5cbiAgdXNlTGF5b3V0RWZmZWN0KCgpID0+IHtcbiAgICBpZiAodGFyZ2V0KSB7XG4gICAgICB0YXJnZXQuYWRkRXZlbnRMaXN0ZW5lcihldmVudCwgb25DYWxsZWRDYWxsYmFjaylcblxuICAgICAgcmV0dXJuICgpID0+IHtcbiAgICAgICAgdGFyZ2V0LnJlbW92ZUV2ZW50TGlzdGVuZXIoZXZlbnQsIG9uQ2FsbGVkQ2FsbGJhY2spXG4gICAgICB9XG4gICAgfVxuICB9LCBbdGFyZ2V0LCBldmVudCwgb25DYWxsZWRdKVxufVxuXG5leHBvcnQgZGVmYXVsdCBBcGlNYWtlclVzZUV2ZW50TGlzdGVuZXJcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsV0FBVyxFQUFFQyxlQUFlLFFBQU8sT0FBTztBQUVsRCxNQUFNQyx3QkFBd0IsR0FBR0EsQ0FBQ0MsTUFBTSxFQUFFQyxLQUFLLEVBQUVDLFFBQVEsS0FBSztFQUM1RCxNQUFNQyxnQkFBZ0IsR0FBR04sV0FBVyxDQUFDLENBQUMsR0FBR08sSUFBSSxLQUFLO0lBQ2hERixRQUFRLENBQUNHLEtBQUssQ0FBQyxJQUFJLEVBQUVELElBQUksQ0FBQztFQUM1QixDQUFDLEVBQUUsQ0FBQ0osTUFBTSxFQUFFQyxLQUFLLEVBQUVDLFFBQVEsQ0FBQyxDQUFDO0VBRTdCSixlQUFlLENBQUMsTUFBTTtJQUNwQixJQUFJRSxNQUFNLEVBQUU7TUFDVkEsTUFBTSxDQUFDTSxnQkFBZ0IsQ0FBQ0wsS0FBSyxFQUFFRSxnQkFBZ0IsQ0FBQztNQUVoRCxPQUFPLE1BQU07UUFDWEgsTUFBTSxDQUFDTyxtQkFBbUIsQ0FBQ04sS0FBSyxFQUFFRSxnQkFBZ0IsQ0FBQztNQUNyRCxDQUFDO0lBQ0g7RUFDRixDQUFDLEVBQUUsQ0FBQ0gsTUFBTSxFQUFFQyxLQUFLLEVBQUVDLFFBQVEsQ0FBQyxDQUFDO0FBQy9CLENBQUM7QUFFRCxlQUFlSCx3QkFBd0IiLCJpZ25vcmVMaXN0IjpbXX0=