@kaspernj/api-maker 1.0.2011 → 1.0.2012

package/build/source-maps-loader.js

@@ -0,0 +1,184 @@
+import * as stackTraceParser from "stacktrace-parser";
+import Logger from "./logger";
+import { SourceMapConsumer } from "source-map";
+import uniqunize from "uniqunize";
+
+// Sometimes this needs to be called and sometimes not
+if (SourceMapConsumer.initialize) {
+  SourceMapConsumer.initialize({
+    "lib/mappings.wasm": "https://unpkg.com/source-map@0.7.4/lib/mappings.wasm"
+  });
+}
+const logger = new Logger({
+  name: "ApiMaker / SourceMapsLoader"
+});
+export default class SourceMapsLoader {
+  constructor() {
+    this.isLoadingSourceMaps = false;
+    this.sourceMaps = [];
+    this.srcLoaded = {};
+  }
+  loadSourceMapsForScriptTags(callback) {
+    this.loadSourceMapsForScriptTagsCallback = callback;
+  }
+  sourceMapForSource(callback) {
+    this.sourceMapForSourceCallback = callback;
+  }
+  async loadSourceMaps(error) {
+    if (!error) throw new Error("No error was given to SourceMapsLoader#loadSourceMaps");
+    this.isLoadingSourceMaps = true;
+    try {
+      const promises = [];
+      const sources = this.getSources(error);
+      for (const source of sources) {
+        if (source.originalUrl && !this.srcLoaded[source.originalUrl]) {
+          this.srcLoaded[source.originalUrl] = true;
+          const promise = this.loadSourceMapForSource(source);
+          promises.push(promise);
+        }
+      }
+      await Promise.all(promises);
+    } finally {
+      this.isLoadingSourceMaps = false;
+    }
+  }
+  getSources(error) {
+    let sources = this.getSourcesFromScripts();
+    if (error) sources = sources.concat(this.getSourcesFromError(error));
+    return uniqunize(sources, source => source.originalUrl);
+  }
+  getSourcesFromError(error) {
+    const stack = stackTraceParser.parse(error.stack);
+    const sources = [];
+    for (const trace of stack) {
+      const file = trace.file;
+      if (file != "\u003Canonymous>") {
+        const sourceMapUrl = this.getMapURL({
+          src: file
+        });
+        if (sourceMapUrl) {
+          logger.debug(() => `Found source map from error: ${sourceMapUrl}`);
+          sources.push({
+            originalUrl: file,
+            sourceMapUrl
+          });
+        } else {
+          logger.debug(() => `Coudn't get source map from: ${file}`);
+        }
+      }
+    }
+    return sources;
+  }
+  getSourcesFromScripts() {
+    const scripts = document.querySelectorAll("script");
+    const sources = [];
+    for (const script of scripts) {
+      const sourceMapUrl = this.getMapURL({
+        script,
+        src: script.src
+      });
+      if (sourceMapUrl) {
+        logger.debug(() => `Found source map from script: ${sourceMapUrl}`);
+        sources.push({
+          originalUrl: script.src,
+          sourceMapUrl
+        });
+      }
+    }
+    return sources;
+  }
+  getMapURL({
+    script,
+    src
+  }) {
+    const url = this.loadUrl(src);
+    const originalUrl = `${url.origin}${url.pathname}`;
+    if (this.sourceMapForSourceCallback) {
+      // Use custom callback to resolve which map-file to download
+      return this.sourceMapForSourceCallback({
+        originalUrl,
+        script,
+        src,
+        url
+      });
+    } else if (this.includeMapURL(src)) {
+      // Default to original URL with '.map' appended
+      return `${originalUrl}.map`;
+    }
+  }
+  includeMapURL = src => src.includes("/packs/");
+  async loadSourceMapForSource({
+    originalUrl,
+    sourceMapUrl
+  }) {
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", sourceMapUrl, true);
+    try {
+      await this.loadXhr(xhr, sourceMapUrl);
+    } catch (error) {
+      console.log(`Couldn't load source map from: ${sourceMapUrl}: ${xhr.responseText}`);
+      return;
+    }
+    const consumer = await new SourceMapConsumer(xhr.responseText);
+    if (consumer) {
+      this.sourceMaps.push({
+        consumer,
+        originalUrl
+      });
+    }
+  }
+  loadUrl(url) {
+    const parser = document.createElement("a");
+    parser.href = url;
+    return parser;
+  }
+  loadXhr(xhr, url) {
+    return new Promise((resolve, reject) => {
+      xhr.onload = () => {
+        if (xhr.status == 200) {
+          resolve();
+        } else {
+          reject(new Error(`HTTP request failed with ${xhr.status} for ${url}`));
+        }
+      };
+      xhr.send();
+    });
+  }
+  parseStackTrace(stackTrace) {
+    return this.getStackTraceData(stackTrace).map(traceData => `at ${traceData.methodName} (${traceData.fileString})`);
+  }
+  getStackTraceData(stackTrace) {
+    const stack = stackTraceParser.parse(stackTrace);
+    const newSourceMap = [];
+    for (const trace of stack) {
+      const sourceMapData = this.sourceMaps.find(sourceMapData => sourceMapData.originalUrl == trace.file);
+      let filePath, fileString, original;
+      if (sourceMapData) {
+        original = sourceMapData.consumer.originalPositionFor({
+          line: trace.lineNumber,
+          column: trace.column
+        });
+      }
+      if (original && original.source) {
+        filePath = original.source.replace(/^webpack:\/\/(app|)\//, "");
+        fileString = `${filePath}:${original.line}`;
+        if (original.column) {
+          fileString += `:${original.column}`;
+        }
+      } else {
+        filePath = trace.file;
+        fileString = `${filePath}:${trace.lineNumber}`;
+        if (trace.column) {
+          fileString += `:${trace.column}`;
+        }
+      }
+      newSourceMap.push({
+        filePath,
+        fileString,
+        methodName: trace.methodName
+      });
+    }
+    return newSourceMap;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stackTraceParser","Logger","SourceMapConsumer","uniqunize","initialize","logger","name","SourceMapsLoader","constructor","isLoadingSourceMaps","sourceMaps","srcLoaded","loadSourceMapsForScriptTags","callback","loadSourceMapsForScriptTagsCallback","sourceMapForSource","sourceMapForSourceCallback","loadSourceMaps","error","Error","promises","sources","getSources","source","originalUrl","promise","loadSourceMapForSource","push","Promise","all","getSourcesFromScripts","concat","getSourcesFromError","stack","parse","trace","file","sourceMapUrl","getMapURL","src","debug","scripts","document","querySelectorAll","script","url","loadUrl","origin","pathname","includeMapURL","includes","xhr","XMLHttpRequest","open","loadXhr","console","log","responseText","consumer","parser","createElement","href","resolve","reject","onload","status","send","parseStackTrace","stackTrace","getStackTraceData","map","traceData","methodName","fileString","newSourceMap","sourceMapData","find","filePath","original","originalPositionFor","line","lineNumber","column","replace"],"sources":["../src/source-maps-loader.js"],"sourcesContent":["import * as stackTraceParser from \"stacktrace-parser\"\nimport Logger from \"./logger\"\nimport {SourceMapConsumer} from \"source-map\"\nimport uniqunize from \"uniqunize\"\n\n// Sometimes this needs to be called and sometimes not\nif (SourceMapConsumer.initialize) {\n  SourceMapConsumer.initialize({\n    \"lib/mappings.wasm\": \"https://unpkg.com/source-map@0.7.4/lib/mappings.wasm\"\n  })\n}\n\nconst logger = new Logger({name: \"ApiMaker / SourceMapsLoader\"})\n\nexport default class SourceMapsLoader {\n  constructor() {\n    this.isLoadingSourceMaps = false\n    this.sourceMaps = []\n    this.srcLoaded = {}\n  }\n\n  loadSourceMapsForScriptTags(callback) {\n    this.loadSourceMapsForScriptTagsCallback = callback\n  }\n\n  sourceMapForSource(callback) {\n    this.sourceMapForSourceCallback = callback\n  }\n\n  async loadSourceMaps(error) {\n    if (!error) throw new Error(\"No error was given to SourceMapsLoader#loadSourceMaps\")\n\n    this.isLoadingSourceMaps = true\n\n    try {\n      const promises = []\n      const sources = this.getSources(error)\n\n      for(const source of sources) {\n        if (source.originalUrl && !this.srcLoaded[source.originalUrl]) {\n          this.srcLoaded[source.originalUrl] = true\n\n          const promise = this.loadSourceMapForSource(source)\n          promises.push(promise)\n        }\n      }\n\n      await Promise.all(promises)\n    } finally {\n      this.isLoadingSourceMaps = false\n    }\n  }\n\n  getSources(error) {\n    let sources = this.getSourcesFromScripts()\n\n    if (error) sources = sources.concat(this.getSourcesFromError(error))\n\n    return uniqunize(sources, (source) => source.originalUrl)\n  }\n\n  getSourcesFromError(error) {\n    const stack = stackTraceParser.parse(error.stack)\n    const sources = []\n\n    for (const trace of stack) {\n      const file = trace.file\n\n      if (file != \"\\u003Canonymous>\") {\n        const sourceMapUrl = this.getMapURL({src: file})\n\n        if (sourceMapUrl) {\n          logger.debug(() => `Found source map from error: ${sourceMapUrl}`)\n\n          sources.push({originalUrl: file, sourceMapUrl})\n        } else {\n          logger.debug(() => `Coudn't get source map from: ${file}`)\n        }\n      }\n    }\n\n    return sources\n  }\n\n  getSourcesFromScripts() {\n    const scripts = document.querySelectorAll(\"script\")\n    const sources = []\n\n    for (const script of scripts) {\n      const sourceMapUrl = this.getMapURL({script, src: script.src})\n\n      if (sourceMapUrl) {\n        logger.debug(() => `Found source map from script: ${sourceMapUrl}`)\n        sources.push({originalUrl: script.src, sourceMapUrl})\n      }\n    }\n\n    return sources\n  }\n\n  getMapURL({script, src}) {\n    const url = this.loadUrl(src)\n    const originalUrl = `${url.origin}${url.pathname}`\n\n    if (this.sourceMapForSourceCallback) {\n      // Use custom callback to resolve which map-file to download\n      return this.sourceMapForSourceCallback({originalUrl, script, src, url})\n    } else if (this.includeMapURL(src)) {\n      // Default to original URL with '.map' appended\n      return `${originalUrl}.map`\n    }\n  }\n\n  includeMapURL = (src) => src.includes(\"/packs/\")\n\n  async loadSourceMapForSource({originalUrl, sourceMapUrl}) {\n    const xhr = new XMLHttpRequest()\n\n    xhr.open(\"GET\", sourceMapUrl, true)\n\n    try {\n      await this.loadXhr(xhr, sourceMapUrl)\n    } catch (error) {\n      console.log(`Couldn't load source map from: ${sourceMapUrl}: ${xhr.responseText}`)\n\n      return\n    }\n\n    const consumer = await new SourceMapConsumer(xhr.responseText)\n\n    if (consumer) {\n      this.sourceMaps.push({consumer, originalUrl})\n    }\n  }\n\n  loadUrl(url) {\n    const parser = document.createElement(\"a\")\n\n    parser.href = url\n\n    return parser\n  }\n\n  loadXhr(xhr, url) {\n    return new Promise((resolve, reject) => {\n      xhr.onload = () => {\n        if (xhr.status == 200) {\n          resolve()\n        } else {\n          reject(new Error(`HTTP request failed with ${xhr.status} for ${url}`))\n        }\n      }\n      xhr.send()\n    })\n  }\n\n  parseStackTrace(stackTrace) {\n    return this.getStackTraceData(stackTrace)\n      .map((traceData) => `at ${traceData.methodName} (${traceData.fileString})`)\n  }\n\n  getStackTraceData(stackTrace) {\n    const stack = stackTraceParser.parse(stackTrace)\n    const newSourceMap = []\n\n    for (const trace of stack) {\n      const sourceMapData = this.sourceMaps.find((sourceMapData) => sourceMapData.originalUrl == trace.file)\n\n      let filePath, fileString, original\n\n      if (sourceMapData) {\n        original = sourceMapData.consumer.originalPositionFor({\n          line: trace.lineNumber,\n          column: trace.column\n        })\n      }\n\n      if (original && original.source) {\n        filePath = original.source.replace(/^webpack:\\/\\/(app|)\\//, \"\")\n        fileString = `${filePath}:${original.line}`\n\n        if (original.column) {\n          fileString += `:${original.column}`\n        }\n      } else {\n        filePath = trace.file\n        fileString = `${filePath}:${trace.lineNumber}`\n\n        if (trace.column) {\n          fileString += `:${trace.column}`\n        }\n      }\n\n      newSourceMap.push({\n        filePath,\n        fileString,\n        methodName: trace.methodName\n      })\n    }\n\n    return newSourceMap\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/super-admin/config-reader.js

@@ -0,0 +1,85 @@
+import { digg, digs } from "diggerize";
+import * as inflection from "inflection";
+const modelConfigRequireContext = require.context("super-admin/model-configs", true, /.jsx$/);
+export default class ApiMakerSuperAdminConfigReader {
+  static forModel(modelClass) {
+    const modelNameCamelized = digg(modelClass.modelClassData(), "nameDasherized");
+    let modelConfig;
+    try {
+      modelConfig = modelConfigRequireContext(`./${modelNameCamelized}.jsx`).default;
+    } catch (error) {
+      if (error.message.includes("Cannot find module")) {
+        console.debug(`No model-config for ${modelClass.modelClassData().name}`);
+      } else {
+        throw error;
+      }
+    }
+    return new ApiMakerSuperAdminConfigReader(modelClass, modelConfig);
+  }
+  constructor(modelClass, modelConfig) {
+    this.modelClass = modelClass;
+    this.modelConfig = modelConfig;
+  }
+  attributesToShow() {
+    const {
+      modelConfig
+    } = digs(this, "modelConfig");
+    if (modelConfig?.show?.attributesToShow) {
+      return modelConfig.show.attributesToShow();
+    }
+    return this.defaultAttributesToShow();
+  }
+  defaultAttributesToShow() {
+    const attributesToShow = [];
+    const {
+      columns
+    } = this.defaultTableColumns();
+    for (const column of columns) {
+      attributesToShow.push(digg(column, "attribute"));
+    }
+    return attributesToShow;
+  }
+  tableColumns() {
+    const {
+      modelConfig
+    } = digs(this, "modelConfig");
+    if (modelConfig?.table?.columns) {
+      return {
+        columns: modelConfig.table.columns()
+      };
+    } else {
+      return this.defaultTableColumns();
+    }
+  }
+  defaultTableColumns() {
+    const {
+      modelClass
+    } = digs(this, "modelClass");
+    const attributes = modelClass.attributes();
+    const columns = [];
+    const select = {};
+    const modelClassSelect = [];
+    select[modelClass.modelClassData().name] = modelClassSelect;
+    for (const attribute of attributes) {
+      if (!attribute.isSelectedByDefault() && attribute.name() != "name") {
+        continue;
+      }
+      const camelizedName = inflection.camelize(attribute.name(), true);
+      const column = {
+        attribute: camelizedName
+      };
+      if (attribute.isColumn()) {
+        column.sortKey = camelizedName;
+      } else if (attribute.isTranslated()) {
+        column.sortKey = `currentTranslation${camelizedName}`;
+      }
+      modelClassSelect.push(camelizedName);
+      columns.push(column);
+    }
+    return {
+      columns,
+      select
+    };
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/super-admin/edit-page/edit-attribute-checkbox.js

@@ -0,0 +1,85 @@
+import React, { useMemo } from "react";
+import { StyleSheet, View } from "react-native";
+import Checkbox from "../../utils/checkbox";
+import BaseComponent from "../../base-component";
+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 { useForm } from "../../form";
+const styles = StyleSheet.create({
+  checkbox: {
+    marginRight: 4
+  }
+});
+export default memo(shapeComponent(class EditAttributeInput extends BaseComponent {
+  static propTypes = propTypesExact({
+    attributeName: PropTypes.string.isRequired,
+    id: PropTypes.string.isRequired,
+    label: PropTypes.string.isRequired,
+    model: PropTypes.object.isRequired,
+    name: PropTypes.string.isRequired
+  });
+  setup() {
+    const {
+      attributeName,
+      id,
+      name
+    } = this.p;
+    this.form = useForm();
+    this.useStates({
+      checked: this.tt.defaultChecked
+    });
+    this.dataSet = useMemo(() => ({
+      attribute: attributeName,
+      id,
+      name
+    }), [attributeName, id, name]);
+    useMemo(() => {
+      if (this.form) {
+        this.form.setValue(name, this.s.checked);
+      }
+    }, []);
+  }
+  defaultChecked = () => this.p.model[this.p.attributeName]() || false;
+  render() {
+    const {
+      dataSet
+    } = this.tt;
+    const {
+      attributeName,
+      label,
+      model
+    } = this.p;
+    const {
+      checked
+    } = this.s;
+    if (!(attributeName in model)) {
+      throw new Error(`${attributeName} isn't set on the resource ${model.modelClassData().name}`);
+    }
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker/super-admin/edit-page/edit-attribute-input"
+      },
+      style: {
+        flexDirection: "row",
+        alignItems: "center"
+      }
+    }, /*#__PURE__*/React.createElement(Checkbox, {
+      checked: checked,
+      dataSet: dataSet,
+      label: label,
+      onCheckedChange: this.tt.onCheckedChange,
+      style: styles.checkbox
+    }));
+  }
+  onCheckedChange = newChecked => {
+    if (this.form) {
+      this.form.setValue(this.p.name, newChecked);
+    }
+    this.setState({
+      checked: newChecked
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZU1lbW8iLCJTdHlsZVNoZWV0IiwiVmlldyIsIkNoZWNrYm94IiwiQmFzZUNvbXBvbmVudCIsIm1lbW8iLCJQcm9wVHlwZXMiLCJwcm9wVHlwZXNFeGFjdCIsInNoYXBlQ29tcG9uZW50IiwidXNlRm9ybSIsInN0eWxlcyIsImNyZWF0ZSIsImNoZWNrYm94IiwibWFyZ2luUmlnaHQiLCJFZGl0QXR0cmlidXRlSW5wdXQiLCJwcm9wVHlwZXMiLCJhdHRyaWJ1dGVOYW1lIiwic3RyaW5nIiwiaXNSZXF1aXJlZCIsImlkIiwibGFiZWwiLCJtb2RlbCIsIm9iamVjdCIsIm5hbWUiLCJzZXR1cCIsInAiLCJmb3JtIiwidXNlU3RhdGVzIiwiY2hlY2tlZCIsInR0IiwiZGVmYXVsdENoZWNrZWQiLCJkYXRhU2V0IiwiYXR0cmlidXRlIiwic2V0VmFsdWUiLCJzIiwicmVuZGVyIiwiRXJyb3IiLCJtb2RlbENsYXNzRGF0YSIsImNyZWF0ZUVsZW1lbnQiLCJjb21wb25lbnQiLCJzdHlsZSIsImZsZXhEaXJlY3Rpb24iLCJhbGlnbkl0ZW1zIiwib25DaGVja2VkQ2hhbmdlIiwibmV3Q2hlY2tlZCIsInNldFN0YXRlIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N1cGVyLWFkbWluL2VkaXQtcGFnZS9lZGl0LWF0dHJpYnV0ZS1jaGVja2JveC5qc3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7dXNlTWVtb30gZnJvbSBcInJlYWN0XCJcbmltcG9ydCB7U3R5bGVTaGVldCwgVmlld30gZnJvbSBcInJlYWN0LW5hdGl2ZVwiXG5pbXBvcnQgQ2hlY2tib3ggZnJvbSBcIi4uLy4uL3V0aWxzL2NoZWNrYm94XCJcbmltcG9ydCBCYXNlQ29tcG9uZW50IGZyb20gXCIuLi8uLi9iYXNlLWNvbXBvbmVudFwiXG5pbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL21lbW9cIlxuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiXG5pbXBvcnQgcHJvcFR5cGVzRXhhY3QgZnJvbSBcInByb3AtdHlwZXMtZXhhY3RcIlxuaW1wb3J0IHtzaGFwZUNvbXBvbmVudH0gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL3NyYy9zaGFwZS1jb21wb25lbnRcIlxuaW1wb3J0IHt1c2VGb3JtfSBmcm9tIFwiLi4vLi4vZm9ybVwiXG5cbmNvbnN0IHN0eWxlcyA9IFN0eWxlU2hlZXQuY3JlYXRlKHtcbiAgY2hlY2tib3g6IHtcbiAgICBtYXJnaW5SaWdodDogNFxuICB9XG59KVxuXG5leHBvcnQgZGVmYXVsdCBtZW1vKHNoYXBlQ29tcG9uZW50KGNsYXNzIEVkaXRBdHRyaWJ1dGVJbnB1dCBleHRlbmRzIEJhc2VDb21wb25lbnQge1xuICBzdGF0aWMgcHJvcFR5cGVzID0gcHJvcFR5cGVzRXhhY3Qoe1xuICAgIGF0dHJpYnV0ZU5hbWU6IFByb3BUeXBlcy5zdHJpbmcuaXNSZXF1aXJlZCxcbiAgICBpZDogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICAgIGxhYmVsOiBQcm9wVHlwZXMuc3RyaW5nLmlzUmVxdWlyZWQsXG4gICAgbW9kZWw6IFByb3BUeXBlcy5vYmplY3QuaXNSZXF1aXJlZCxcbiAgICBuYW1lOiBQcm9wVHlwZXMuc3RyaW5nLmlzUmVxdWlyZWRcbiAgfSlcblxuICBzZXR1cCgpIHtcbiAgICBjb25zdCB7YXR0cmlidXRlTmFtZSwgaWQsIG5hbWV9ID0gdGhpcy5wXG5cbiAgICB0aGlzLmZvcm0gPSB1c2VGb3JtKClcbiAgICB0aGlzLnVzZVN0YXRlcyh7XG4gICAgICBjaGVja2VkOiB0aGlzLnR0LmRlZmF1bHRDaGVja2VkXG4gICAgfSlcblxuICAgIHRoaXMuZGF0YVNldCA9IHVzZU1lbW8oXG4gICAgICAoKSA9PiAoe1xuICAgICAgICBhdHRyaWJ1dGU6IGF0dHJpYnV0ZU5hbWUsXG4gICAgICAgIGlkLFxuICAgICAgICBuYW1lXG4gICAgICB9KSxcbiAgICAgIFthdHRyaWJ1dGVOYW1lLCBpZCwgbmFtZV1cbiAgICApXG5cbiAgICB1c2VNZW1vKCgpID0+IHtcbiAgICAgIGlmICh0aGlzLmZvcm0pIHtcbiAgICAgICAgdGhpcy5mb3JtLnNldFZhbHVlKG5hbWUsIHRoaXMucy5jaGVja2VkKVxuICAgICAgfVxuICAgIH0sIFtdKVxuICB9XG5cbiAgZGVmYXVsdENoZWNrZWQgPSAoKSA9PiB0aGlzLnAubW9kZWxbdGhpcy5wLmF0dHJpYnV0ZU5hbWVdKCkgfHwgZmFsc2VcblxuICByZW5kZXIoKSB7XG4gICAgY29uc3Qge2RhdGFTZXR9ID0gdGhpcy50dFxuICAgIGNvbnN0IHthdHRyaWJ1dGVOYW1lLCBsYWJlbCwgbW9kZWx9ID0gdGhpcy5wXG4gICAgY29uc3Qge2NoZWNrZWR9ID0gdGhpcy5zXG5cbiAgICBpZiAoIShhdHRyaWJ1dGVOYW1lIGluIG1vZGVsKSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGAke2F0dHJpYnV0ZU5hbWV9IGlzbid0IHNldCBvbiB0aGUgcmVzb3VyY2UgJHttb2RlbC5tb2RlbENsYXNzRGF0YSgpLm5hbWV9YClcbiAgICB9XG5cbiAgICByZXR1cm4gKFxuICAgICAgPFZpZXcgZGF0YVNldD17e2NvbXBvbmVudDogXCJhcGktbWFrZXIvc3VwZXItYWRtaW4vZWRpdC1wYWdlL2VkaXQtYXR0cmlidXRlLWlucHV0XCJ9fSBzdHlsZT17e2ZsZXhEaXJlY3Rpb246IFwicm93XCIsIGFsaWduSXRlbXM6IFwiY2VudGVyXCJ9fT5cbiAgICAgICAgPENoZWNrYm94XG4gICAgICAgICAgY2hlY2tlZD17Y2hlY2tlZH1cbiAgICAgICAgICBkYXRhU2V0PXtkYXRhU2V0fVxuICAgICAgICAgIGxhYmVsPXtsYWJlbH1cbiAgICAgICAgICBvbkNoZWNrZWRDaGFuZ2U9e3RoaXMudHQub25DaGVja2VkQ2hhbmdlfVxuICAgICAgICAgIHN0eWxlPXtzdHlsZXMuY2hlY2tib3h9XG4gICAgICAgIC8+XG4gICAgICA8L1ZpZXc+XG4gICAgKVxuICB9XG5cbiAgb25DaGVja2VkQ2hhbmdlID0gKG5ld0NoZWNrZWQpID0+IHtcbiAgICBpZiAodGhpcy5mb3JtKSB7XG4gICAgICB0aGlzLmZvcm0uc2V0VmFsdWUodGhpcy5wLm5hbWUsIG5ld0NoZWNrZWQpXG4gICAgfVxuXG4gICAgdGhpcy5zZXRTdGF0ZSh7Y2hlY2tlZDogbmV3Q2hlY2tlZH0pXG4gIH1cbn0pKVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxLQUFLLElBQUdDLE9BQU8sUUFBTyxPQUFPO0FBQ3BDLFNBQVFDLFVBQVUsRUFBRUMsSUFBSSxRQUFPLGNBQWM7QUFDN0MsT0FBT0MsUUFBUSxNQUFNLHNCQUFzQjtBQUMzQyxPQUFPQyxhQUFhLE1BQU0sc0JBQXNCO0FBQ2hELE9BQU9DLElBQUksTUFBTSw0QkFBNEI7QUFDN0MsT0FBT0MsU0FBUyxNQUFNLFlBQVk7QUFDbEMsT0FBT0MsY0FBYyxNQUFNLGtCQUFrQjtBQUM3QyxTQUFRQyxjQUFjLFFBQU8sdUNBQXVDO0FBQ3BFLFNBQVFDLE9BQU8sUUFBTyxZQUFZO0FBRWxDLE1BQU1DLE1BQU0sR0FBR1QsVUFBVSxDQUFDVSxNQUFNLENBQUM7RUFDL0JDLFFBQVEsRUFBRTtJQUNSQyxXQUFXLEVBQUU7RUFDZjtBQUNGLENBQUMsQ0FBQztBQUVGLGVBQWVSLElBQUksQ0FBQ0csY0FBYyxDQUFDLE1BQU1NLGtCQUFrQixTQUFTVixhQUFhLENBQUM7RUFDaEYsT0FBT1csU0FBUyxHQUFHUixjQUFjLENBQUM7SUFDaENTLGFBQWEsRUFBRVYsU0FBUyxDQUFDVyxNQUFNLENBQUNDLFVBQVU7SUFDMUNDLEVBQUUsRUFBRWIsU0FBUyxDQUFDVyxNQUFNLENBQUNDLFVBQVU7SUFDL0JFLEtBQUssRUFBRWQsU0FBUyxDQUFDVyxNQUFNLENBQUNDLFVBQVU7SUFDbENHLEtBQUssRUFBRWYsU0FBUyxDQUFDZ0IsTUFBTSxDQUFDSixVQUFVO0lBQ2xDSyxJQUFJLEVBQUVqQixTQUFTLENBQUNXLE1BQU0sQ0FBQ0M7RUFDekIsQ0FBQyxDQUFDO0VBRUZNLEtBQUtBLENBQUEsRUFBRztJQUNOLE1BQU07TUFBQ1IsYUFBYTtNQUFFRyxFQUFFO01BQUVJO0lBQUksQ0FBQyxHQUFHLElBQUksQ0FBQ0UsQ0FBQztJQUV4QyxJQUFJLENBQUNDLElBQUksR0FBR2pCLE9BQU8sQ0FBQyxDQUFDO0lBQ3JCLElBQUksQ0FBQ2tCLFNBQVMsQ0FBQztNQUNiQyxPQUFPLEVBQUUsSUFBSSxDQUFDQyxFQUFFLENBQUNDO0lBQ25CLENBQUMsQ0FBQztJQUVGLElBQUksQ0FBQ0MsT0FBTyxHQUFHL0IsT0FBTyxDQUNwQixPQUFPO01BQ0xnQyxTQUFTLEVBQUVoQixhQUFhO01BQ3hCRyxFQUFFO01BQ0ZJO0lBQ0YsQ0FBQyxDQUFDLEVBQ0YsQ0FBQ1AsYUFBYSxFQUFFRyxFQUFFLEVBQUVJLElBQUksQ0FDMUIsQ0FBQztJQUVEdkIsT0FBTyxDQUFDLE1BQU07TUFDWixJQUFJLElBQUksQ0FBQzBCLElBQUksRUFBRTtRQUNiLElBQUksQ0FBQ0EsSUFBSSxDQUFDTyxRQUFRLENBQUNWLElBQUksRUFBRSxJQUFJLENBQUNXLENBQUMsQ0FBQ04sT0FBTyxDQUFDO01BQzFDO0lBQ0YsQ0FBQyxFQUFFLEVBQUUsQ0FBQztFQUNSO0VBRUFFLGNBQWMsR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ0wsQ0FBQyxDQUFDSixLQUFLLENBQUMsSUFBSSxDQUFDSSxDQUFDLENBQUNULGFBQWEsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLO0VBRXBFbUIsTUFBTUEsQ0FBQSxFQUFHO0lBQ1AsTUFBTTtNQUFDSjtJQUFPLENBQUMsR0FBRyxJQUFJLENBQUNGLEVBQUU7SUFDekIsTUFBTTtNQUFDYixhQUFhO01BQUVJLEtBQUs7TUFBRUM7SUFBSyxDQUFDLEdBQUcsSUFBSSxDQUFDSSxDQUFDO0lBQzVDLE1BQU07TUFBQ0c7SUFBTyxDQUFDLEdBQUcsSUFBSSxDQUFDTSxDQUFDO0lBRXhCLElBQUksRUFBRWxCLGFBQWEsSUFBSUssS0FBSyxDQUFDLEVBQUU7TUFDN0IsTUFBTSxJQUFJZSxLQUFLLENBQUMsR0FBR3BCLGFBQWEsOEJBQThCSyxLQUFLLENBQUNnQixjQUFjLENBQUMsQ0FBQyxDQUFDZCxJQUFJLEVBQUUsQ0FBQztJQUM5RjtJQUVBLG9CQUNFeEIsS0FBQSxDQUFBdUMsYUFBQSxDQUFDcEMsSUFBSTtNQUFDNkIsT0FBTyxFQUFFO1FBQUNRLFNBQVMsRUFBRTtNQUFzRCxDQUFFO01BQUNDLEtBQUssRUFBRTtRQUFDQyxhQUFhLEVBQUUsS0FBSztRQUFFQyxVQUFVLEVBQUU7TUFBUTtJQUFFLGdCQUN0STNDLEtBQUEsQ0FBQXVDLGFBQUEsQ0FBQ25DLFFBQVE7TUFDUHlCLE9BQU8sRUFBRUEsT0FBUTtNQUNqQkcsT0FBTyxFQUFFQSxPQUFRO01BQ2pCWCxLQUFLLEVBQUVBLEtBQU07TUFDYnVCLGVBQWUsRUFBRSxJQUFJLENBQUNkLEVBQUUsQ0FBQ2MsZUFBZ0I7TUFDekNILEtBQUssRUFBRTlCLE1BQU0sQ0FBQ0U7SUFBUyxDQUN4QixDQUNHLENBQUM7RUFFWDtFQUVBK0IsZUFBZSxHQUFJQyxVQUFVLElBQUs7SUFDaEMsSUFBSSxJQUFJLENBQUNsQixJQUFJLEVBQUU7TUFDYixJQUFJLENBQUNBLElBQUksQ0FBQ08sUUFBUSxDQUFDLElBQUksQ0FBQ1IsQ0FBQyxDQUFDRixJQUFJLEVBQUVxQixVQUFVLENBQUM7SUFDN0M7SUFFQSxJQUFJLENBQUNDLFFBQVEsQ0FBQztNQUFDakIsT0FBTyxFQUFFZ0I7SUFBVSxDQUFDLENBQUM7RUFDdEMsQ0FBQztBQUNILENBQUMsQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/build/super-admin/edit-page/edit-attribute-content.js

@@ -0,0 +1,55 @@
+import BaseComponent from "../../base-component";
+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 { useForm } from "../../form";
+import { useMemo } from "react";
+export default memo(shapeComponent(class EditAttributeContent extends BaseComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.object.isRequired,
+    id: PropTypes.string.isRequired,
+    model: PropTypes.object.isRequired,
+    name: PropTypes.string.isRequired
+  });
+  setup() {
+    this.form = useForm();
+    this.useStates({
+      value: () => this.defaultValue()
+    });
+  }
+  render() {
+    const {
+      attribute,
+      id,
+      model
+    } = this.props;
+    if (!(attribute.attribute in model)) {
+      throw new Error(`${attribute.attribute} isn't set on the resource ${model.modelClassData().name}`);
+    }
+    const contentArgs = useMemo(() => ({
+      inputProps: {
+        attribute: attribute.attribute,
+        defaultValue: this.defaultValue(),
+        id,
+        model
+      },
+      onChangeValue: this.tt.onChangeValue,
+      value: this.s.value
+    }), [attribute.attribute, id, model, this.s.value]);
+    return attribute.content(contentArgs);
+  }
+  defaultValue = () => {
+    if (!(this.p.attribute.attribute in this.p.model)) {
+      throw new Error(`No attribute called ${this.p.attribute.attribute} in model ${this.p.model.modelClassData().name}`);
+    }
+    return this.p.model[this.p.attribute.attribute]() || "";
+  };
+  onChangeValue = newValue => {
+    this.setState({
+      value: newValue
+    });
+    this.tt.form.setValue(this.p.name, newValue);
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/super-admin/edit-page/edit-attribute-input.js

@@ -0,0 +1,79 @@
+import React, { useMemo } from "react";
+import { TextInput, View } from "react-native";
+import BaseComponent from "../../base-component";
+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 Text from "../../utils/text";
+import { useForm } from "../../form";
+export default memo(shapeComponent(class EditAttributeInput extends BaseComponent {
+  static propTypes = propTypesExact({
+    attributeName: PropTypes.string.isRequired,
+    id: PropTypes.string.isRequired,
+    label: PropTypes.string.isRequired,
+    model: PropTypes.object.isRequired,
+    name: PropTypes.string.isRequired
+  });
+  setup() {
+    const {
+      name
+    } = this.p;
+    this.form = useForm();
+    this.useStates({
+      value: this.defaultValue()
+    });
+    useMemo(() => {
+      if (this.form) {
+        this.form.setValue(name, this.s.value);
+      }
+    }, []);
+  }
+  defaultValue = () => this.p.model[this.p.attributeName]() || "";
+  render() {
+    const {
+      attributeName,
+      id,
+      label,
+      model,
+      name
+    } = this.p;
+    const {
+      value
+    } = this.s;
+    if (!(attributeName in model)) {
+      throw new Error(`${attributeName} isn't set on the resource ${model.modelClassData().name}`);
+    }
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker/super-admin/edit-page/edit-attribute-input"
+      }
+    }, /*#__PURE__*/React.createElement(Text, null, label), /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement(TextInput, {
+      dataSet: {
+        attribute: attributeName,
+        id,
+        name
+      },
+      onChangeText: this.tt.onChangeText,
+      style: {
+        paddingTop: 9,
+        paddingRight: 13,
+        paddingBottom: 9,
+        paddingLeft: 13,
+        borderRadius: 5,
+        backgroundColor: "#fff",
+        border: "1px solid #cecece"
+      },
+      value: value
+    })));
+  }
+  onChangeText = newValue => {
+    if (this.form) {
+      this.form.setValue(this.p.name, newValue);
+    }
+    this.setState({
+      value: newValue
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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