@kaspernj/api-maker 1.0.446 → 1.0.447

package/build/source-maps-loader.js

@@ -0,0 +1,171 @@
+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.3/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);
+    await this.loadXhr(xhr);
+    const consumer = await new SourceMapConsumer(xhr.responseText);
+    this.sourceMaps.push({
+      consumer,
+      originalUrl
+    });
+  }
+  loadUrl(url) {
+    const parser = document.createElement("a");
+    parser.href = url;
+    return parser;
+  }
+  loadXhr(xhr, postData) {
+    return new Promise(resolve => {
+      xhr.onload = () => resolve();
+      xhr.send(postData);
+    });
+  }
+  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","consumer","responseText","parser","createElement","href","postData","resolve","onload","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.3/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    await this.loadXhr(xhr)\n\n    const consumer = await new SourceMapConsumer(xhr.responseText)\n\n    this.sourceMaps.push({consumer, originalUrl})\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, postData) {\n    return new Promise((resolve) => {\n      xhr.onload = () => resolve()\n      xhr.send(postData)\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,84 @@
+import { digg, digs } from "diggerize";
+import * as inflection from "inflection";
+export default class ApiMakerSuperAdminConfigReader {
+  static forModel(modelClass) {
+    const modelNameCamelized = digg(modelClass.modelClassData(), "nameDasherized");
+    let modelConfig;
+    try {
+      modelConfig = require(`super-admin/model-configs/${modelNameCamelized}`).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 { 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,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

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

@@ -0,0 +1,54 @@
+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";
+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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCYXNlQ29tcG9uZW50IiwibWVtbyIsIlByb3BUeXBlcyIsInByb3BUeXBlc0V4YWN0Iiwic2hhcGVDb21wb25lbnQiLCJ1c2VGb3JtIiwiRWRpdEF0dHJpYnV0ZUNvbnRlbnQiLCJwcm9wVHlwZXMiLCJhdHRyaWJ1dGUiLCJvYmplY3QiLCJpc1JlcXVpcmVkIiwiaWQiLCJzdHJpbmciLCJtb2RlbCIsIm5hbWUiLCJzZXR1cCIsImZvcm0iLCJ1c2VTdGF0ZXMiLCJ2YWx1ZSIsImRlZmF1bHRWYWx1ZSIsInJlbmRlciIsInByb3BzIiwiRXJyb3IiLCJtb2RlbENsYXNzRGF0YSIsImNvbnRlbnRBcmdzIiwidXNlTWVtbyIsImlucHV0UHJvcHMiLCJvbkNoYW5nZVZhbHVlIiwidHQiLCJzIiwiY29udGVudCIsInAiLCJuZXdWYWx1ZSIsInNldFN0YXRlIiwic2V0VmFsdWUiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3VwZXItYWRtaW4vZWRpdC1wYWdlL2VkaXQtYXR0cmlidXRlLWNvbnRlbnQuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBCYXNlQ29tcG9uZW50IGZyb20gXCIuLi8uLi9iYXNlLWNvbXBvbmVudFwiXG5pbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL21lbW9cIlxuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiXG5pbXBvcnQgcHJvcFR5cGVzRXhhY3QgZnJvbSBcInByb3AtdHlwZXMtZXhhY3RcIlxuaW1wb3J0IHtzaGFwZUNvbXBvbmVudH0gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL3NyYy9zaGFwZS1jb21wb25lbnRcIlxuaW1wb3J0IHt1c2VGb3JtfSBmcm9tIFwiLi4vLi4vZm9ybVwiXG5cbmV4cG9ydCBkZWZhdWx0IG1lbW8oc2hhcGVDb21wb25lbnQoY2xhc3MgRWRpdEF0dHJpYnV0ZUNvbnRlbnQgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcbiAgc3RhdGljIHByb3BUeXBlcyA9IHByb3BUeXBlc0V4YWN0KHtcbiAgICBhdHRyaWJ1dGU6IFByb3BUeXBlcy5vYmplY3QuaXNSZXF1aXJlZCxcbiAgICBpZDogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICAgIG1vZGVsOiBQcm9wVHlwZXMub2JqZWN0LmlzUmVxdWlyZWQsXG4gICAgbmFtZTogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkXG4gIH0pXG5cbiAgc2V0dXAoKSB7XG4gICAgdGhpcy5mb3JtID0gdXNlRm9ybSgpXG4gICAgdGhpcy51c2VTdGF0ZXMoe1xuICAgICAgdmFsdWU6ICgpID0+IHRoaXMuZGVmYXVsdFZhbHVlKClcbiAgICB9KVxuICB9XG5cbiAgcmVuZGVyKCkge1xuICAgIGNvbnN0IHthdHRyaWJ1dGUsIGlkLCBtb2RlbH0gPSB0aGlzLnByb3BzXG5cbiAgICBpZiAoIShhdHRyaWJ1dGUuYXR0cmlidXRlIGluIG1vZGVsKSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGAke2F0dHJpYnV0ZS5hdHRyaWJ1dGV9IGlzbid0IHNldCBvbiB0aGUgcmVzb3VyY2UgJHttb2RlbC5tb2RlbENsYXNzRGF0YSgpLm5hbWV9YClcbiAgICB9XG5cbiAgICBjb25zdCBjb250ZW50QXJncyA9IHVzZU1lbW8oKCkgPT4gKHtcbiAgICAgIGlucHV0UHJvcHM6IHtcbiAgICAgICAgYXR0cmlidXRlOiBhdHRyaWJ1dGUuYXR0cmlidXRlLFxuICAgICAgICBkZWZhdWx0VmFsdWU6IHRoaXMuZGVmYXVsdFZhbHVlKCksXG4gICAgICAgIGlkLFxuICAgICAgICBtb2RlbFxuICAgICAgfSxcbiAgICAgIG9uQ2hhbmdlVmFsdWU6IHRoaXMudHQub25DaGFuZ2VWYWx1ZSxcbiAgICAgIHZhbHVlOiB0aGlzLnMudmFsdWVcbiAgICB9KSwgW2F0dHJpYnV0ZS5hdHRyaWJ1dGUsIGlkLCBtb2RlbCwgdGhpcy5zLnZhbHVlXSlcblxuICAgIHJldHVybiBhdHRyaWJ1dGUuY29udGVudChjb250ZW50QXJncylcbiAgfVxuXG4gIGRlZmF1bHRWYWx1ZSA9ICgpID0+IHtcbiAgICBpZiAoISh0aGlzLnAuYXR0cmlidXRlLmF0dHJpYnV0ZSBpbiB0aGlzLnAubW9kZWwpKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoYE5vIGF0dHJpYnV0ZSBjYWxsZWQgJHt0aGlzLnAuYXR0cmlidXRlLmF0dHJpYnV0ZX0gaW4gbW9kZWwgJHt0aGlzLnAubW9kZWwubW9kZWxDbGFzc0RhdGEoKS5uYW1lfWApXG4gICAgfVxuXG4gICAgcmV0dXJuIHRoaXMucC5tb2RlbFt0aGlzLnAuYXR0cmlidXRlLmF0dHJpYnV0ZV0oKSB8fCBcIlwiXG4gIH1cblxuICBvbkNoYW5nZVZhbHVlID0gKG5ld1ZhbHVlKSA9PiB7XG4gICAgdGhpcy5zZXRTdGF0ZSh7dmFsdWU6IG5ld1ZhbHVlfSlcbiAgICB0aGlzLnR0LmZvcm0uc2V0VmFsdWUodGhpcy5wLm5hbWUsIG5ld1ZhbHVlKVxuICB9XG59KSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsYUFBYSxNQUFNLHNCQUFzQjtBQUNoRCxPQUFPQyxJQUFJLE1BQU0sNEJBQTRCO0FBQzdDLE9BQU9DLFNBQVMsTUFBTSxZQUFZO0FBQ2xDLE9BQU9DLGNBQWMsTUFBTSxrQkFBa0I7QUFDN0MsU0FBUUMsY0FBYyxRQUFPLHVDQUF1QztBQUNwRSxTQUFRQyxPQUFPLFFBQU8sWUFBWTtBQUVsQyxlQUFlSixJQUFJLENBQUNHLGNBQWMsQ0FBQyxNQUFNRSxvQkFBb0IsU0FBU04sYUFBYSxDQUFDO0VBQ2xGLE9BQU9PLFNBQVMsR0FBR0osY0FBYyxDQUFDO0lBQ2hDSyxTQUFTLEVBQUVOLFNBQVMsQ0FBQ08sTUFBTSxDQUFDQyxVQUFVO0lBQ3RDQyxFQUFFLEVBQUVULFNBQVMsQ0FBQ1UsTUFBTSxDQUFDRixVQUFVO0lBQy9CRyxLQUFLLEVBQUVYLFNBQVMsQ0FBQ08sTUFBTSxDQUFDQyxVQUFVO0lBQ2xDSSxJQUFJLEVBQUVaLFNBQVMsQ0FBQ1UsTUFBTSxDQUFDRjtFQUN6QixDQUFDLENBQUM7RUFFRkssS0FBS0EsQ0FBQSxFQUFHO0lBQ04sSUFBSSxDQUFDQyxJQUFJLEdBQUdYLE9BQU8sQ0FBQyxDQUFDO0lBQ3JCLElBQUksQ0FBQ1ksU0FBUyxDQUFDO01BQ2JDLEtBQUssRUFBRUEsQ0FBQSxLQUFNLElBQUksQ0FBQ0MsWUFBWSxDQUFDO0lBQ2pDLENBQUMsQ0FBQztFQUNKO0VBRUFDLE1BQU1BLENBQUEsRUFBRztJQUNQLE1BQU07TUFBQ1osU0FBUztNQUFFRyxFQUFFO01BQUVFO0lBQUssQ0FBQyxHQUFHLElBQUksQ0FBQ1EsS0FBSztJQUV6QyxJQUFJLEVBQUViLFNBQVMsQ0FBQ0EsU0FBUyxJQUFJSyxLQUFLLENBQUMsRUFBRTtNQUNuQyxNQUFNLElBQUlTLEtBQUssQ0FBQyxHQUFHZCxTQUFTLENBQUNBLFNBQVMsOEJBQThCSyxLQUFLLENBQUNVLGNBQWMsQ0FBQyxDQUFDLENBQUNULElBQUksRUFBRSxDQUFDO0lBQ3BHO0lBRUEsTUFBTVUsV0FBVyxHQUFHQyxPQUFPLENBQUMsT0FBTztNQUNqQ0MsVUFBVSxFQUFFO1FBQ1ZsQixTQUFTLEVBQUVBLFNBQVMsQ0FBQ0EsU0FBUztRQUM5QlcsWUFBWSxFQUFFLElBQUksQ0FBQ0EsWUFBWSxDQUFDLENBQUM7UUFDakNSLEVBQUU7UUFDRkU7TUFDRixDQUFDO01BQ0RjLGFBQWEsRUFBRSxJQUFJLENBQUNDLEVBQUUsQ0FBQ0QsYUFBYTtNQUNwQ1QsS0FBSyxFQUFFLElBQUksQ0FBQ1csQ0FBQyxDQUFDWDtJQUNoQixDQUFDLENBQUMsRUFBRSxDQUFDVixTQUFTLENBQUNBLFNBQVMsRUFBRUcsRUFBRSxFQUFFRSxLQUFLLEVBQUUsSUFBSSxDQUFDZ0IsQ0FBQyxDQUFDWCxLQUFLLENBQUMsQ0FBQztJQUVuRCxPQUFPVixTQUFTLENBQUNzQixPQUFPLENBQUNOLFdBQVcsQ0FBQztFQUN2QztFQUVBTCxZQUFZLEdBQUdBLENBQUEsS0FBTTtJQUNuQixJQUFJLEVBQUUsSUFBSSxDQUFDWSxDQUFDLENBQUN2QixTQUFTLENBQUNBLFNBQVMsSUFBSSxJQUFJLENBQUN1QixDQUFDLENBQUNsQixLQUFLLENBQUMsRUFBRTtNQUNqRCxNQUFNLElBQUlTLEtBQUssQ0FBQyx1QkFBdUIsSUFBSSxDQUFDUyxDQUFDLENBQUN2QixTQUFTLENBQUNBLFNBQVMsYUFBYSxJQUFJLENBQUN1QixDQUFDLENBQUNsQixLQUFLLENBQUNVLGNBQWMsQ0FBQyxDQUFDLENBQUNULElBQUksRUFBRSxDQUFDO0lBQ3JIO0lBRUEsT0FBTyxJQUFJLENBQUNpQixDQUFDLENBQUNsQixLQUFLLENBQUMsSUFBSSxDQUFDa0IsQ0FBQyxDQUFDdkIsU0FBUyxDQUFDQSxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRTtFQUN6RCxDQUFDO0VBRURtQixhQUFhLEdBQUlLLFFBQVEsSUFBSztJQUM1QixJQUFJLENBQUNDLFFBQVEsQ0FBQztNQUFDZixLQUFLLEVBQUVjO0lBQVEsQ0FBQyxDQUFDO0lBQ2hDLElBQUksQ0FBQ0osRUFBRSxDQUFDWixJQUFJLENBQUNrQixRQUFRLENBQUMsSUFBSSxDQUFDSCxDQUFDLENBQUNqQixJQUFJLEVBQUVrQixRQUFRLENBQUM7RUFDOUMsQ0FBQztBQUNILENBQUMsQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

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

@@ -0,0 +1,79 @@
+import { 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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VNZW1vIiwiVGV4dElucHV0IiwiVmlldyIsIkJhc2VDb21wb25lbnQiLCJtZW1vIiwiUHJvcFR5cGVzIiwicHJvcFR5cGVzRXhhY3QiLCJzaGFwZUNvbXBvbmVudCIsIlRleHQiLCJ1c2VGb3JtIiwiRWRpdEF0dHJpYnV0ZUlucHV0IiwicHJvcFR5cGVzIiwiYXR0cmlidXRlTmFtZSIsInN0cmluZyIsImlzUmVxdWlyZWQiLCJpZCIsImxhYmVsIiwibW9kZWwiLCJvYmplY3QiLCJuYW1lIiwic2V0dXAiLCJwIiwiZm9ybSIsInVzZVN0YXRlcyIsInZhbHVlIiwiZGVmYXVsdFZhbHVlIiwic2V0VmFsdWUiLCJzIiwicmVuZGVyIiwiRXJyb3IiLCJtb2RlbENsYXNzRGF0YSIsIlJlYWN0IiwiY3JlYXRlRWxlbWVudCIsImRhdGFTZXQiLCJjb21wb25lbnQiLCJhdHRyaWJ1dGUiLCJvbkNoYW5nZVRleHQiLCJ0dCIsInN0eWxlIiwicGFkZGluZ1RvcCIsInBhZGRpbmdSaWdodCIsInBhZGRpbmdCb3R0b20iLCJwYWRkaW5nTGVmdCIsImJvcmRlclJhZGl1cyIsImJhY2tncm91bmRDb2xvciIsImJvcmRlciIsIm5ld1ZhbHVlIiwic2V0U3RhdGUiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3VwZXItYWRtaW4vZWRpdC1wYWdlL2VkaXQtYXR0cmlidXRlLWlucHV0LmpzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge3VzZU1lbW99IGZyb20gXCJyZWFjdFwiXG5pbXBvcnQge1RleHRJbnB1dCwgVmlld30gZnJvbSBcInJlYWN0LW5hdGl2ZVwiXG5pbXBvcnQgQmFzZUNvbXBvbmVudCBmcm9tIFwiLi4vLi4vYmFzZS1jb21wb25lbnRcIlxuaW1wb3J0IG1lbW8gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL3NyYy9tZW1vXCJcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSBcInByb3AtdHlwZXNcIlxuaW1wb3J0IHByb3BUeXBlc0V4YWN0IGZyb20gXCJwcm9wLXR5cGVzLWV4YWN0XCJcbmltcG9ydCB7c2hhcGVDb21wb25lbnR9IGZyb20gXCJzZXQtc3RhdGUtY29tcGFyZS9zcmMvc2hhcGUtY29tcG9uZW50XCJcbmltcG9ydCBUZXh0IGZyb20gXCIuLi8uLi91dGlscy90ZXh0XCJcbmltcG9ydCB7dXNlRm9ybX0gZnJvbSBcIi4uLy4uL2Zvcm1cIlxuXG5leHBvcnQgZGVmYXVsdCBtZW1vKHNoYXBlQ29tcG9uZW50KGNsYXNzIEVkaXRBdHRyaWJ1dGVJbnB1dCBleHRlbmRzIEJhc2VDb21wb25lbnQge1xuICBzdGF0aWMgcHJvcFR5cGVzID0gcHJvcFR5cGVzRXhhY3Qoe1xuICAgIGF0dHJpYnV0ZU5hbWU6IFByb3BUeXBlcy5zdHJpbmcuaXNSZXF1aXJlZCxcbiAgICBpZDogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICAgIGxhYmVsOiBQcm9wVHlwZXMuc3RyaW5nLmlzUmVxdWlyZWQsXG4gICAgbW9kZWw6IFByb3BUeXBlcy5vYmplY3QuaXNSZXF1aXJlZCxcbiAgICBuYW1lOiBQcm9wVHlwZXMuc3RyaW5nLmlzUmVxdWlyZWRcbiAgfSlcblxuICBzZXR1cCgpIHtcbiAgICBjb25zdCB7bmFtZX0gPSB0aGlzLnBcblxuICAgIHRoaXMuZm9ybSA9IHVzZUZvcm0oKVxuICAgIHRoaXMudXNlU3RhdGVzKHtcbiAgICAgIHZhbHVlOiB0aGlzLmRlZmF1bHRWYWx1ZSgpXG4gICAgfSlcblxuICAgIHVzZU1lbW8oKCkgPT4ge1xuICAgICAgaWYgKHRoaXMuZm9ybSkge1xuICAgICAgICB0aGlzLmZvcm0uc2V0VmFsdWUobmFtZSwgdGhpcy5zLnZhbHVlKVxuICAgICAgfVxuICAgIH0sIFtdKVxuICB9XG5cbiAgZGVmYXVsdFZhbHVlID0gKCkgPT4gdGhpcy5wLm1vZGVsW3RoaXMucC5hdHRyaWJ1dGVOYW1lXSgpIHx8IFwiXCJcblxuICByZW5kZXIoKSB7XG4gICAgY29uc3Qge2F0dHJpYnV0ZU5hbWUsIGlkLCBsYWJlbCwgbW9kZWwsIG5hbWV9ID0gdGhpcy5wXG4gICAgY29uc3Qge3ZhbHVlfSA9IHRoaXMuc1xuXG4gICAgaWYgKCEoYXR0cmlidXRlTmFtZSBpbiBtb2RlbCkpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgJHthdHRyaWJ1dGVOYW1lfSBpc24ndCBzZXQgb24gdGhlIHJlc291cmNlICR7bW9kZWwubW9kZWxDbGFzc0RhdGEoKS5uYW1lfWApXG4gICAgfVxuXG4gICAgcmV0dXJuIChcbiAgICAgIDxWaWV3IGRhdGFTZXQ9e3tjb21wb25lbnQ6IFwiYXBpLW1ha2VyL3N1cGVyLWFkbWluL2VkaXQtcGFnZS9lZGl0LWF0dHJpYnV0ZS1pbnB1dFwifX0+XG4gICAgICAgIDxUZXh0PntsYWJlbH08L1RleHQ+XG4gICAgICAgIDxWaWV3PlxuICAgICAgICAgIDxUZXh0SW5wdXRcbiAgICAgICAgICAgIGRhdGFTZXQ9e3tcbiAgICAgICAgICAgICAgYXR0cmlidXRlOiBhdHRyaWJ1dGVOYW1lLFxuICAgICAgICAgICAgICBpZCxcbiAgICAgICAgICAgICAgbmFtZVxuICAgICAgICAgICAgfX1cbiAgICAgICAgICAgIG9uQ2hhbmdlVGV4dD17dGhpcy50dC5vbkNoYW5nZVRleHR9XG4gICAgICAgICAgICBzdHlsZT17e3BhZGRpbmdUb3A6IDksIHBhZGRpbmdSaWdodDogMTMsIHBhZGRpbmdCb3R0b206IDksIHBhZGRpbmdMZWZ0OiAxMywgYm9yZGVyUmFkaXVzOiA1LCBiYWNrZ3JvdW5kQ29sb3I6IFwiI2ZmZlwiLCBib3JkZXI6IFwiMXB4IHNvbGlkICNjZWNlY2VcIn19XG4gICAgICAgICAgICB2YWx1ZT17dmFsdWV9XG4gICAgICAgICAgLz5cbiAgICAgICAgPC9WaWV3PlxuICAgICAgPC9WaWV3PlxuICAgIClcbiAgfVxuXG4gIG9uQ2hhbmdlVGV4dCA9IChuZXdWYWx1ZSkgPT4ge1xuICAgIGlmICh0aGlzLmZvcm0pIHtcbiAgICAgIHRoaXMuZm9ybS5zZXRWYWx1ZSh0aGlzLnAubmFtZSwgbmV3VmFsdWUpXG4gICAgfVxuXG4gICAgdGhpcy5zZXRTdGF0ZSh7dmFsdWU6IG5ld1ZhbHVlfSlcbiAgfVxufSkpXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVFBLE9BQU8sUUFBTyxPQUFPO0FBQzdCLFNBQVFDLFNBQVMsRUFBRUMsSUFBSSxRQUFPLGNBQWM7QUFDNUMsT0FBT0MsYUFBYSxNQUFNLHNCQUFzQjtBQUNoRCxPQUFPQyxJQUFJLE1BQU0sNEJBQTRCO0FBQzdDLE9BQU9DLFNBQVMsTUFBTSxZQUFZO0FBQ2xDLE9BQU9DLGNBQWMsTUFBTSxrQkFBa0I7QUFDN0MsU0FBUUMsY0FBYyxRQUFPLHVDQUF1QztBQUNwRSxPQUFPQyxJQUFJLE1BQU0sa0JBQWtCO0FBQ25DLFNBQVFDLE9BQU8sUUFBTyxZQUFZO0FBRWxDLGVBQWVMLElBQUksQ0FBQ0csY0FBYyxDQUFDLE1BQU1HLGtCQUFrQixTQUFTUCxhQUFhLENBQUM7RUFDaEYsT0FBT1EsU0FBUyxHQUFHTCxjQUFjLENBQUM7SUFDaENNLGFBQWEsRUFBRVAsU0FBUyxDQUFDUSxNQUFNLENBQUNDLFVBQVU7SUFDMUNDLEVBQUUsRUFBRVYsU0FBUyxDQUFDUSxNQUFNLENBQUNDLFVBQVU7SUFDL0JFLEtBQUssRUFBRVgsU0FBUyxDQUFDUSxNQUFNLENBQUNDLFVBQVU7SUFDbENHLEtBQUssRUFBRVosU0FBUyxDQUFDYSxNQUFNLENBQUNKLFVBQVU7SUFDbENLLElBQUksRUFBRWQsU0FBUyxDQUFDUSxNQUFNLENBQUNDO0VBQ3pCLENBQUMsQ0FBQztFQUVGTSxLQUFLQSxDQUFBLEVBQUc7SUFDTixNQUFNO01BQUNEO0lBQUksQ0FBQyxHQUFHLElBQUksQ0FBQ0UsQ0FBQztJQUVyQixJQUFJLENBQUNDLElBQUksR0FBR2IsT0FBTyxDQUFDLENBQUM7SUFDckIsSUFBSSxDQUFDYyxTQUFTLENBQUM7TUFDYkMsS0FBSyxFQUFFLElBQUksQ0FBQ0MsWUFBWSxDQUFDO0lBQzNCLENBQUMsQ0FBQztJQUVGekIsT0FBTyxDQUFDLE1BQU07TUFDWixJQUFJLElBQUksQ0FBQ3NCLElBQUksRUFBRTtRQUNiLElBQUksQ0FBQ0EsSUFBSSxDQUFDSSxRQUFRLENBQUNQLElBQUksRUFBRSxJQUFJLENBQUNRLENBQUMsQ0FBQ0gsS0FBSyxDQUFDO01BQ3hDO0lBQ0YsQ0FBQyxFQUFFLEVBQUUsQ0FBQztFQUNSO0VBRUFDLFlBQVksR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ0osQ0FBQyxDQUFDSixLQUFLLENBQUMsSUFBSSxDQUFDSSxDQUFDLENBQUNULGFBQWEsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFO0VBRS9EZ0IsTUFBTUEsQ0FBQSxFQUFHO0lBQ1AsTUFBTTtNQUFDaEIsYUFBYTtNQUFFRyxFQUFFO01BQUVDLEtBQUs7TUFBRUMsS0FBSztNQUFFRTtJQUFJLENBQUMsR0FBRyxJQUFJLENBQUNFLENBQUM7SUFDdEQsTUFBTTtNQUFDRztJQUFLLENBQUMsR0FBRyxJQUFJLENBQUNHLENBQUM7SUFFdEIsSUFBSSxFQUFFZixhQUFhLElBQUlLLEtBQUssQ0FBQyxFQUFFO01BQzdCLE1BQU0sSUFBSVksS0FBSyxDQUFDLEdBQUdqQixhQUFhLDhCQUE4QkssS0FBSyxDQUFDYSxjQUFjLENBQUMsQ0FBQyxDQUFDWCxJQUFJLEVBQUUsQ0FBQztJQUM5RjtJQUVBLG9CQUNFWSxLQUFBLENBQUFDLGFBQUEsQ0FBQzlCLElBQUk7TUFBQytCLE9BQU8sRUFBRTtRQUFDQyxTQUFTLEVBQUU7TUFBc0Q7SUFBRSxnQkFDakZILEtBQUEsQ0FBQUMsYUFBQSxDQUFDeEIsSUFBSSxRQUFFUSxLQUFZLENBQUMsZUFDcEJlLEtBQUEsQ0FBQUMsYUFBQSxDQUFDOUIsSUFBSSxxQkFDSDZCLEtBQUEsQ0FBQUMsYUFBQSxDQUFDL0IsU0FBUztNQUNSZ0MsT0FBTyxFQUFFO1FBQ1BFLFNBQVMsRUFBRXZCLGFBQWE7UUFDeEJHLEVBQUU7UUFDRkk7TUFDRixDQUFFO01BQ0ZpQixZQUFZLEVBQUUsSUFBSSxDQUFDQyxFQUFFLENBQUNELFlBQWE7TUFDbkNFLEtBQUssRUFBRTtRQUFDQyxVQUFVLEVBQUUsQ0FBQztRQUFFQyxZQUFZLEVBQUUsRUFBRTtRQUFFQyxhQUFhLEVBQUUsQ0FBQztRQUFFQyxXQUFXLEVBQUUsRUFBRTtRQUFFQyxZQUFZLEVBQUUsQ0FBQztRQUFFQyxlQUFlLEVBQUUsTUFBTTtRQUFFQyxNQUFNLEVBQUU7TUFBbUIsQ0FBRTtNQUNuSnJCLEtBQUssRUFBRUE7SUFBTSxDQUNkLENBQ0csQ0FDRixDQUFDO0VBRVg7RUFFQVksWUFBWSxHQUFJVSxRQUFRLElBQUs7SUFDM0IsSUFBSSxJQUFJLENBQUN4QixJQUFJLEVBQUU7TUFDYixJQUFJLENBQUNBLElBQUksQ0FBQ0ksUUFBUSxDQUFDLElBQUksQ0FBQ0wsQ0FBQyxDQUFDRixJQUFJLEVBQUUyQixRQUFRLENBQUM7SUFDM0M7SUFFQSxJQUFJLENBQUNDLFFBQVEsQ0FBQztNQUFDdkIsS0FBSyxFQUFFc0I7SUFBUSxDQUFDLENBQUM7RUFDbEMsQ0FBQztBQUNILENBQUMsQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

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

@@ -0,0 +1,76 @@
+import BaseComponent from "../../base-component";
+import { digg } from "diggerize";
+import EditAttributeCheckbox from "./edit-attribute-checkbox";
+import EditAttributeContent from "./edit-attribute-content";
+import EditAttributeInput from "./edit-attribute-input";
+import * as inflection from "inflection";
+import Locales from "shared/locales";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import { View } from "react-native";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+export default memo(shapeComponent(class EditAttribute extends BaseComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.object.isRequired,
+    model: PropTypes.object,
+    modelClass: PropTypes.func
+  });
+  render() {
+    const {
+      attribute,
+      model,
+      modelClass
+    } = this.props;
+    const availableLocales = Locales.availableLocales();
+    const camelizedLower = digg(modelClass.modelClassData(), "camelizedLower");
+    const modelAttribute = modelClass.attributes().find(modelAttributeI => modelAttributeI.name() == attribute.attribute);
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker/super-admin/edit-page/edit-attribute"
+      },
+      style: {
+        marginBottom: attribute.translated ? undefined : 12
+      }
+    }, (() => {
+      if (attribute.content) {
+        return /*#__PURE__*/React.createElement(EditAttributeContent, {
+          attribute: attribute,
+          id: `${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`,
+          model: model,
+          name: inflection.underscore(attribute.attribute)
+        });
+      } else if (attribute.translated) {
+        return /*#__PURE__*/React.createElement(React.Fragment, null, availableLocales.map(locale => /*#__PURE__*/React.createElement(View, {
+          key: locale,
+          style: {
+            marginBottom: 12
+          }
+        }, /*#__PURE__*/React.createElement(EditAttributeInput, {
+          attributeName: `${attribute.attribute}${inflection.camelize(locale)}`,
+          id: `${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}_${locale}`,
+          label: `${modelClass.humanAttributeName(attribute.attribute)} (${locale})`,
+          model: model,
+          name: `${inflection.underscore(attribute.attribute)}_${locale}`
+        }))));
+      } else if (modelAttribute?.getColumn()?.getType() == "boolean") {
+        return /*#__PURE__*/React.createElement(EditAttributeCheckbox, {
+          attributeName: attribute.attribute,
+          id: `${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`,
+          label: modelClass.humanAttributeName(attribute.attribute),
+          model: model,
+          name: inflection.underscore(attribute.attribute)
+        });
+      } else {
+        return /*#__PURE__*/React.createElement(EditAttributeInput, {
+          attributeName: attribute.attribute,
+          id: `${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`,
+          label: modelClass.humanAttributeName(attribute.attribute),
+          model: model,
+          name: inflection.underscore(attribute.attribute)
+        });
+      }
+    })());
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","digg","EditAttributeCheckbox","EditAttributeContent","EditAttributeInput","inflection","Locales","memo","PropTypes","propTypesExact","View","shapeComponent","EditAttribute","propTypes","attribute","object","isRequired","model","modelClass","func","render","props","availableLocales","camelizedLower","modelClassData","modelAttribute","attributes","find","modelAttributeI","name","React","createElement","dataSet","component","style","marginBottom","translated","undefined","content","id","underscore","Fragment","map","locale","key","attributeName","camelize","label","humanAttributeName","getColumn","getType"],"sources":["../../../src/super-admin/edit-page/edit-attribute.jsx"],"sourcesContent":["import BaseComponent from \"../../base-component\"\nimport {digg} from \"diggerize\"\nimport EditAttributeCheckbox from \"./edit-attribute-checkbox\"\nimport EditAttributeContent from \"./edit-attribute-content\"\nimport EditAttributeInput from \"./edit-attribute-input\"\nimport * as inflection from \"inflection\"\nimport Locales from \"shared/locales\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport {View} from \"react-native\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\n\nexport default memo(shapeComponent(class EditAttribute extends BaseComponent {\n  static propTypes = propTypesExact({\n    attribute: PropTypes.object.isRequired,\n    model: PropTypes.object,\n    modelClass: PropTypes.func\n  })\n\n  render() {\n    const {attribute, model, modelClass} = this.props\n    const availableLocales = Locales.availableLocales()\n    const camelizedLower = digg(modelClass.modelClassData(), \"camelizedLower\")\n    const modelAttribute = modelClass.attributes().find((modelAttributeI) => modelAttributeI.name() == attribute.attribute)\n\n    return (\n      <View dataSet={{component: \"api-maker/super-admin/edit-page/edit-attribute\"}} style={{marginBottom: attribute.translated ? undefined : 12}}>\n        {(() => {\n          if (attribute.content) {\n            return (\n              <EditAttributeContent\n                attribute={attribute}\n                id={`${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`}\n                model={model}\n                name={inflection.underscore(attribute.attribute)}\n              />\n            )\n          } else if (attribute.translated) {\n            return (\n              <>\n                {availableLocales.map((locale) =>\n                  <View key={locale} style={{marginBottom: 12}}>\n                    <EditAttributeInput\n                      attributeName={`${attribute.attribute}${inflection.camelize(locale)}`}\n                      id={`${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}_${locale}`}\n                      label={`${modelClass.humanAttributeName(attribute.attribute)} (${locale})`}\n                      model={model}\n                      name={`${inflection.underscore(attribute.attribute)}_${locale}`}\n                    />\n                  </View>\n                )}\n              </>\n            )\n          } else if (modelAttribute?.getColumn()?.getType() == \"boolean\") {\n            return (\n              <EditAttributeCheckbox\n                attributeName={attribute.attribute}\n                id={`${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`}\n                label={modelClass.humanAttributeName(attribute.attribute)}\n                model={model}\n                name={inflection.underscore(attribute.attribute)}\n              />\n            )\n          } else {\n            return (\n              <EditAttributeInput\n                attributeName={attribute.attribute}\n                id={`${inflection.underscore(camelizedLower)}_${inflection.underscore(attribute.attribute)}`}\n                label={modelClass.humanAttributeName(attribute.attribute)}\n                model={model}\n                name={inflection.underscore(attribute.attribute)}\n              />\n            )\n          }\n        })()}\n      </View>\n    )\n  }\n}))\n"],"mappings":"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","ignoreList":[]}