@hanzogui/helpers-node 2.0.0-rc.41-hanzoai.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/dist/getDefaultHanzoguiOptions.cjs

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getDefaultHanzoguiOptions_exports = {};
+__export(getDefaultHanzoguiOptions_exports, {
+  getDefaultHanzoguiOptions: () => getDefaultHanzoguiOptions
+});
+module.exports = __toCommonJS(getDefaultHanzoguiOptions_exports);
+var import_getHanzoguiDefaultPath = require("./getHanzoguiDefaultPath.cjs");
+async function getDefaultHanzoguiOptions({
+  cwd = "."
+}) {
+  return {
+    platform: "native",
+    components: ["hanzogui"],
+    config: await (0, import_getHanzoguiDefaultPath.getDefaultHanzoguiConfigPath)({
+      cwd
+    })
+  };
+}

package/dist/getDefaultHanzoguiOptions.native.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getDefaultHanzoguiOptions_exports = {};
+__export(getDefaultHanzoguiOptions_exports, {
+  getDefaultHanzoguiOptions: () => getDefaultHanzoguiOptions
+});
+module.exports = __toCommonJS(getDefaultHanzoguiOptions_exports);
+var import_getHanzoguiDefaultPath = require("./getHanzoguiDefaultPath.native.js");
+async function getDefaultHanzoguiOptions(param) {
+  var {
+    cwd = "."
+  } = param;
+  return {
+    platform: "native",
+    components: ["hanzogui"],
+    config: await (0, import_getHanzoguiDefaultPath.getDefaultHanzoguiConfigPath)({
+      cwd
+    })
+  };
+}
+//# sourceMappingURL=getDefaultHanzoguiOptions.native.js.map

package/dist/getDefaultHanzoguiOptions.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","getDefaultHanzoguiOptions_exports","__export","getDefaultHanzoguiOptions","module","exports","import_getHanzoguiDefaultPath","require","param","cwd","platform","components","config","getDefaultHanzoguiConfigPath"],"sources":["../src/getDefaultHanzoguiOptions.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,iCAAA;AAAAC,QAAA,CAAAD,iCAAA;EAAAE,yBAAA,EAAAA,CAAA,KAAAA;AAAA;AAEAC,MAAA,CAAAC,OAAA,GAAAT,YAAA,CAAAK,iCAA6C;AAE7C,IAAAK,6BAAsB,GAAAC,OAA0B;AAAA,eACxCJ,0BAAAK,KAAA;EACR,IAE6B;IAAAC,GAAA;EAAA,IAAAD,KAAA;EAC3B,OAAO;IACLE,QAAA,EAAU;IACVC,UAAA,EAAY,CACZ,UAAQ,CACV;IACFC,MAAA,YAAAN,6BAAA,CAAAO,4BAAA","ignoreList":[]}

package/dist/getHanzoguiDefaultPath.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getHanzoguiDefaultPath_exports = {};
+__export(getHanzoguiDefaultPath_exports, {
+  getDefaultHanzoguiConfigPath: () => getDefaultHanzoguiConfigPath
+});
+module.exports = __toCommonJS(getHanzoguiDefaultPath_exports);
+var import_node_path = require("node:path");
+var import_fs_extra = require("fs-extra");
+let cachedPath = "";
+async function getDefaultHanzoguiConfigPath({
+  cwd = ".",
+  cache = true
+}) {
+  if (cache && cachedPath) {
+    return cachedPath;
+  }
+  const defaultPaths = ["hanzogui.config.ts", (0, import_node_path.join)("src", "hanzogui.config.ts")].map(p => (0, import_node_path.join)(cwd, p));
+  const existing = (await Promise.all(defaultPaths.map(path => (0, import_fs_extra.pathExists)(path)))).findIndex(x => !!x);
+  const found = defaultPaths[existing];
+  if (!found) {
+    throw new Error(`No found hanzogui.config.ts`);
+  }
+  cachedPath = found;
+  return found;
+}

package/dist/getHanzoguiDefaultPath.native.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getHanzoguiDefaultPath_exports = {};
+__export(getHanzoguiDefaultPath_exports, {
+  getDefaultHanzoguiConfigPath: () => getDefaultHanzoguiConfigPath
+});
+module.exports = __toCommonJS(getHanzoguiDefaultPath_exports);
+var import_path = require("path");
+var import_fs_extra = require("fs-extra");
+var cachedPath = "";
+async function getDefaultHanzoguiConfigPath(param) {
+  var {
+    cwd = ".",
+    cache = true
+  } = param;
+  if (cache && cachedPath) {
+    return cachedPath;
+  }
+  var defaultPaths = ["hanzogui.config.ts", (0, import_path.join)("src", "hanzogui.config.ts")].map(function (p) {
+    return (0, import_path.join)(cwd, p);
+  });
+  var existing = (await Promise.all(defaultPaths.map(function (path) {
+    return (0, import_fs_extra.pathExists)(path);
+  }))).findIndex(function (x) {
+    return !!x;
+  });
+  var found = defaultPaths[existing];
+  if (!found) {
+    throw new Error(`No found hanzogui.config.ts`);
+  }
+  cachedPath = found;
+  return found;
+}
+//# sourceMappingURL=getHanzoguiDefaultPath.native.js.map

package/dist/getHanzoguiDefaultPath.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","getHanzoguiDefaultPath_exports","__export","getDefaultHanzoguiConfigPath","module","exports","import_path","require","import_fs_extra","cachedPath","param","cwd","cache","defaultPaths","join","map","p","existing","Promise","all","path","pathExists","findIndex","x","found"],"sources":["../src/getHanzoguiDefaultPath.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,8BAAA;AAAAC,QAAA,CAAAD,8BAAA;EAAAE,4BAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAqB,CAAAK,8BAAA;AAErB,IAAAK,WAAA,GAAAC,OAA2B;AAE3B,IAAIC,eAAa,GAAAD,OAAA;AAEjB,IAAAE,UAAA,GAAsB;AAA6B,eAC3CN,6BAAAO,KAAA;EACN;IAAAC,GAAQ;IAAAC,KAAA;EAAA,IAAAF,KAAA;EACV,IAIoBE,KAAA,IAAAH,UAAA;IAClB,OAAIA,UAAS;EACX;EACF,IAAAI,YAAA,IAEA,oBAAsB,EAA6D,CAAC,GAAAP,WAClF,CAAAQ,IAAA,6BAAW,EACb,CAAAC,GAAA,WAAAC,CAAA;IACA,OAAM,IAAAV,WACE,CAAAQ,IAAA,EAAAH,GAAQ,EAAIK,CAAA;EAEpB;EACA,IAAIC,QAAQ,UAAAC,OAAA,CAAAC,GAAA,CAAAN,YAAA,CAAAE,GAAA,WAAAK,IAAA;IACV,OAAM,IAAIZ,eAAM,CAAAa,UAAA,EAAAD,IAAA;EAClB,KAAAE,SAAA,WAAAC,CAAA;IAEA,SAAAA,CAAA;EACA;EACF,IAAAC,KAAA,GAAAX,YAAA,CAAAI,QAAA","ignoreList":[]}

package/dist/getHanzoguiOptions.cjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getHanzoguiOptions_exports = {};
+__export(getHanzoguiOptions_exports, {
+  getHanzoguiOptions: () => getHanzoguiOptions
+});
+module.exports = __toCommonJS(getHanzoguiOptions_exports);
+var import_readHanzoguiOptions = require("./readHanzoguiOptions.cjs");
+async function getHanzoguiOptions({
+  cwd = "."
+}) {
+  return (await (0, import_readHanzoguiOptions.readHanzoguiOptions)({
+    cwd
+  })).options;
+}

package/dist/getHanzoguiOptions.native.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getHanzoguiOptions_exports = {};
+__export(getHanzoguiOptions_exports, {
+  getHanzoguiOptions: () => getHanzoguiOptions
+});
+module.exports = __toCommonJS(getHanzoguiOptions_exports);
+var import_readHanzoguiOptions = require("./readHanzoguiOptions.native.js");
+async function getHanzoguiOptions(param) {
+  var {
+    cwd = "."
+  } = param;
+  return (await (0, import_readHanzoguiOptions.readHanzoguiOptions)({
+    cwd
+  })).options;
+}
+//# sourceMappingURL=getHanzoguiOptions.native.js.map

package/dist/getHanzoguiOptions.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","getHanzoguiOptions_exports","__export","getHanzoguiOptions","module","exports","import_readHanzoguiOptions","require","param","cwd","readHanzoguiOptions"],"sources":["../src/getHanzoguiOptions.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,0BAAA;AAAAC,QAAA,CAAAD,0BAAA;EAAAE,kBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAA,CAAAK,0BAAoC;AAEpC,IAAAK,0BAAsB,GAAAC,OAAmB;AAAA,eACjCJ,mBAAAK,KAAA;EACR,IAE6D;IAAAC,GAAA;EAAA,IAAAD,KAAA;EAC3D,QAAQ,UAAMF,0BAAA,CAAAI,mBAAA,EAAoB;IACpCD","ignoreList":[]}

package/dist/index.cjs

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./readHanzoguiOptions.cjs"), module.exports);
+__reExport(index_exports, require("./getHanzoguiDefaultPath.cjs"), module.exports);
+__reExport(index_exports, require("./getHanzoguiOptions.cjs"), module.exports);

package/dist/index.native.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./readHanzoguiOptions.native.js"), module.exports);
+__reExport(index_exports, require("./getHanzoguiDefaultPath.native.js"), module.exports);
+__reExport(index_exports, require("./getHanzoguiOptions.native.js"), module.exports);
+//# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","module","exports","__reExport","require"],"sources":["../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAP,YAAc,CAAAK,aAAA;AACdG,UAAA,CAAAH,aAAA,EAAcI,OAAA,qCAAAH,MADd,CAAAC,OAAA;AAEAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,qCAFd,GAAAH,MAAA,CAAAC,OAAA","ignoreList":[]}

package/dist/readHanzoguiOptions.cjs

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var readHanzoguiOptions_exports = {};
+__export(readHanzoguiOptions_exports, {
+  readHanzoguiOptions: () => readHanzoguiOptions
+});
+module.exports = __toCommonJS(readHanzoguiOptions_exports);
+var import_node_path = require("node:path");
+var import_fs_extra = require("fs-extra");
+var import_getDefaultHanzoguiOptions = require("./getDefaultHanzoguiOptions.cjs");
+async function readHanzoguiOptions({
+  cwd = "."
+}) {
+  const filePath = (0, import_node_path.join)(cwd, "hanzogui.json");
+  if (!(await (0, import_fs_extra.pathExists)(filePath))) {
+    return {
+      exists: false,
+      options: await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+        cwd
+      })
+    };
+  }
+  try {
+    const options = await (0, import_fs_extra.readJSON)(filePath);
+    if (!Array.isArray(options.components)) {
+      throw new Error(`Invalid components: not string[]`);
+    }
+    return {
+      exists: true,
+      options: {
+        ...(!options.config && (await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+          cwd
+        }))),
+        ...options
+      }
+    };
+  } catch (err) {
+    console.error(`Error reading hanzogui.json: ${err.message} ${err.stack}`);
+    return {
+      exists: false,
+      options: await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+        cwd
+      })
+    };
+  }
+}

package/dist/readHanzoguiOptions.native.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var readHanzoguiOptions_exports = {};
+__export(readHanzoguiOptions_exports, {
+  readHanzoguiOptions: () => readHanzoguiOptions
+});
+module.exports = __toCommonJS(readHanzoguiOptions_exports);
+var import_path = require("path");
+var import_fs_extra = require("fs-extra");
+var import_getDefaultHanzoguiOptions = require("./getDefaultHanzoguiOptions.native.js");
+async function readHanzoguiOptions(param) {
+  var {
+    cwd = "."
+  } = param;
+  var filePath = (0, import_path.join)(cwd, "hanzogui.json");
+  if (!(await (0, import_fs_extra.pathExists)(filePath))) {
+    return {
+      exists: false,
+      options: await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+        cwd
+      })
+    };
+  }
+  try {
+    var options = await (0, import_fs_extra.readJSON)(filePath);
+    if (!Array.isArray(options.components)) {
+      throw new Error(`Invalid components: not string[]`);
+    }
+    return {
+      exists: true,
+      options: {
+        ...(!options.config && (await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+          cwd
+        }))),
+        ...options
+      }
+    };
+  } catch (err) {
+    console.error(`Error reading hanzogui.json: ${err.message} ${err.stack}`);
+    return {
+      exists: false,
+      options: await (0, import_getDefaultHanzoguiOptions.getDefaultHanzoguiOptions)({
+        cwd
+      })
+    };
+  }
+}
+//# sourceMappingURL=readHanzoguiOptions.native.js.map

package/dist/readHanzoguiOptions.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","readHanzoguiOptions_exports","__export","readHanzoguiOptions","module","exports","import_path","require","import_fs_extra","import_getDefaultHanzoguiOptions","param","cwd","filePath","join","pathExists","exists","options","getDefaultHanzoguiOptions","readJSON","Array","isArray","components","Error","config","err","console","error","message","stack"],"sources":["../src/readHanzoguiOptions.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,2BAAA;AAAAC,QAAA,CAAAD,2BAAA;EAAAE,mBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAqB,CAAAK,2BAAA;AAGrB,IAAAK,WAAA,GAAAC,OAAqC;AAErC,IAAAC,eAAA,GAAAD,OAAA,WAA0C;AAE1C,IAAAE,gCAA0C,GAAEF,OAAM,CAAI,uCAGnD;AACD,eAAMJ,mBAAWA,CAAAO,KAAA;EAEjB,IAAI;IAAEC,GAAA;EAAM,IAAAD,KAAA;EACV,IAAAE,QAAO,OAAAN,WAAA,CAAAO,IAAA,EAAAF,GAAA;EAAA,IACL,SAAQ,GAAAH,eAAA,CAAAM,UAAA,EAAAF,QAAA;IAAA,OACR;MACFG,MAAA;MACFC,OAAA,YAAAP,gCAAA,CAAAQ,yBAAA;QAEIN;MACF;IAEA;EACE;EAAkD,IACpD;IAEA,IAAAK,OAAO,aAAAR,eAAA,CAAAU,QAAA,EAAAN,QAAA;IAAA,IACL,CAAAO,KAAQ,CAAAC,OAAA,CAAAJ,OAAA,CAAAK,UAAA;MACR,UAASC,KAAA;IAAA;IACwD,OAC5D;MACLP,MAAA;MACFC,OAAA;QACF,IAAS,CAAAA,OAAU,CAAAO,MAAA,eAAAd,gCAAA,CAAAQ,yBAAA;UACjBN;QAEA;QACE,GAAAK;MACA;IACF;EACF,SAAAQ,GAAA;IACFC,OAAA,CAAAC,KAAA,iCAAAF,GAAA,CAAAG,OAAA,IAAAH,GAAA,CAAAI,KAAA","ignoreList":[]}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hanzogui/helpers-node",
+  "version": "2.0.0-rc.41-hanzoai.5",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "sideEffects": false,
+  "main": "./dist",
+  "types": "./types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "hanzogui-build",
+    "watch": "hanzogui-build --watch",
+    "clean": "hanzogui-build clean",
+    "clean:build": "hanzogui-build clean:build"
+  },
+  "dependencies": {
+    "@hanzogui/types": "2.0.0-rc.41-hanzoai.5"
+  },
+  "devDependencies": {
+    "@hanzogui/build": "2.0.0-rc.41-hanzoai.5",
+    "fs-extra": "^11.2.0"
+  }
+}

package/src/getDefaultHanzoguiOptions.ts

@@ -0,0 +1,15 @@
+import type { HanzoguiOptions } from '@hanzogui/types'
+
+import { getDefaultHanzoguiConfigPath } from './getHanzoguiDefaultPath'
+
+export async function getDefaultHanzoguiOptions({
+  cwd = '.',
+}: {
+  cwd: string
+}): Promise<HanzoguiOptions> {
+  return {
+    platform: 'native',
+    components: ['hanzogui'],
+    config: await getDefaultHanzoguiConfigPath({ cwd }),
+  }
+}

package/src/getHanzoguiDefaultPath.ts

@@ -0,0 +1,32 @@
+import { join } from 'node:path'
+
+import { pathExists } from 'fs-extra'
+
+let cachedPath = ''
+
+export async function getDefaultHanzoguiConfigPath({
+  cwd = '.',
+  cache = true,
+}: {
+  cwd?: string
+  // TODO this isn't passed down / could avoid
+  cache?: boolean
+}): Promise<string> {
+  if (cache && cachedPath) {
+    return cachedPath
+  }
+
+  const defaultPaths = ['hanzogui.config.ts', join('src', 'hanzogui.config.ts')].map((p) =>
+    join(cwd, p)
+  )
+  const existing = (
+    await Promise.all(defaultPaths.map((path) => pathExists(path)))
+  ).findIndex((x) => !!x)
+  const found = defaultPaths[existing]
+  if (!found) {
+    throw new Error(`No found hanzogui.config.ts`)
+  }
+
+  cachedPath = found
+  return found
+}

package/src/getHanzoguiOptions.ts

@@ -0,0 +1,9 @@
+import { readHanzoguiOptions } from './readHanzoguiOptions'
+
+export async function getHanzoguiOptions({
+  cwd = '.',
+}: {
+  cwd?: string
+}): Promise<import('@hanzogui/types/types').HanzoguiOptions> {
+  return (await readHanzoguiOptions({ cwd })).options
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './readHanzoguiOptions'
+export * from './getHanzoguiDefaultPath'
+export * from './getHanzoguiOptions'

package/src/readHanzoguiOptions.ts

@@ -0,0 +1,43 @@
+import { join } from 'node:path'
+
+import type { HanzoguiOptions } from '@hanzogui/types'
+import { pathExists, readJSON } from 'fs-extra'
+
+import { getDefaultHanzoguiOptions } from './getDefaultHanzoguiOptions'
+
+export async function readHanzoguiOptions({ cwd = '.' }: { cwd: string }): Promise<{
+  exists: boolean
+  options: HanzoguiOptions
+}> {
+  const filePath = join(cwd, 'hanzogui.json')
+
+  if (!(await pathExists(filePath))) {
+    return {
+      exists: false,
+      options: await getDefaultHanzoguiOptions({ cwd }),
+    }
+  }
+
+  try {
+    const options = (await readJSON(filePath)) as HanzoguiOptions
+
+    if (!Array.isArray(options.components)) {
+      throw new Error(`Invalid components: not string[]`)
+    }
+
+    return {
+      exists: true,
+      options: {
+        ...(!options.config && (await getDefaultHanzoguiOptions({ cwd }))),
+        ...options,
+      },
+    }
+  } catch (err: any) {
+    console.error(`Error reading hanzogui.json: ${err.message} ${err.stack}`)
+
+    return {
+      exists: false,
+      options: await getDefaultHanzoguiOptions({ cwd }),
+    }
+  }
+}

package/types/getDefaultHanzoguiOptions.d.ts

@@ -0,0 +1,6 @@
+import type { HanzoguiOptions } from "@hanzogui/types";
+export declare function getDefaultHanzoguiOptions({ cwd }: {
+	cwd: string;
+}): Promise<HanzoguiOptions>;
+
+//# sourceMappingURL=getDefaultHanzoguiOptions.d.ts.map

package/types/getDefaultHanzoguiOptions.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc,uBAAuB;AAIrC,OAAO,iBAAe,0BAA0B,EAC9C,OACC;CACD;IACE,QAAQ",
+  "names": [],
+  "sources": [
+    "src/getDefaultHanzoguiOptions.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { HanzoguiOptions } from '@hanzogui/types'\n\nimport { getDefaultHanzoguiConfigPath } from './getHanzoguiDefaultPath'\n\nexport async function getDefaultHanzoguiOptions({\n  cwd = '.',\n}: {\n  cwd: string\n}): Promise<HanzoguiOptions> {\n  return {\n    platform: 'native',\n    components: ['hanzogui'],\n    config: await getDefaultHanzoguiConfigPath({ cwd }),\n  }\n}\n"
+  ]
+}

package/types/getHanzoguiDefaultPath.d.ts

@@ -0,0 +1,6 @@
+export declare function getDefaultHanzoguiConfigPath({ cwd, cache }: {
+	cwd?: string;
+	cache?: boolean;
+}): Promise<string>;
+
+//# sourceMappingURL=getHanzoguiDefaultPath.d.ts.map

package/types/getHanzoguiDefaultPath.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAMA,OAAO,iBAAe,6BAA6B,EACjD,KACA,SACC;CACD;CAEA;IACE",
+  "names": [],
+  "sources": [
+    "src/getHanzoguiDefaultPath.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { join } from 'node:path'\n\nimport { pathExists } from 'fs-extra'\n\nlet cachedPath = ''\n\nexport async function getDefaultHanzoguiConfigPath({\n  cwd = '.',\n  cache = true,\n}: {\n  cwd?: string\n  // TODO this isn't passed down / could avoid\n  cache?: boolean\n}): Promise<string> {\n  if (cache && cachedPath) {\n    return cachedPath\n  }\n\n  const defaultPaths = ['hanzogui.config.ts', join('src', 'hanzogui.config.ts')].map((p) =>\n    join(cwd, p)\n  )\n  const existing = (\n    await Promise.all(defaultPaths.map((path) => pathExists(path)))\n  ).findIndex((x) => !!x)\n  const found = defaultPaths[existing]\n  if (!found) {\n    throw new Error(`No found hanzogui.config.ts`)\n  }\n\n  cachedPath = found\n  return found\n}\n"
+  ]
+}

package/types/getHanzoguiOptions.d.ts

@@ -0,0 +1,5 @@
+export declare function getHanzoguiOptions({ cwd }: {
+	cwd?: string;
+}): Promise<import("@hanzogui/types/types").HanzoguiOptions>;
+
+//# sourceMappingURL=getHanzoguiOptions.d.ts.map

package/types/getHanzoguiOptions.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAEA,OAAO,iBAAe,mBAAmB,EACvC,OACC;CACD;IACE,eAAe",
+  "names": [],
+  "sources": [
+    "src/getHanzoguiOptions.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { readHanzoguiOptions } from './readHanzoguiOptions'\n\nexport async function getHanzoguiOptions({\n  cwd = '.',\n}: {\n  cwd?: string\n}): Promise<import('@hanzogui/types/types').HanzoguiOptions> {\n  return (await readHanzoguiOptions({ cwd })).options\n}\n"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./readHanzoguiOptions";
+export * from "./getHanzoguiDefaultPath";
+export * from "./getHanzoguiOptions";
+
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc;AACd,cAAc;AACd,cAAc",
+  "names": [],
+  "sources": [
+    "src/index.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "export * from './readHanzoguiOptions'\nexport * from './getHanzoguiDefaultPath'\nexport * from './getHanzoguiOptions'\n"
+  ]
+}

package/types/readHanzoguiOptions.d.ts

@@ -0,0 +1,9 @@
+import type { HanzoguiOptions } from "@hanzogui/types";
+export declare function readHanzoguiOptions({ cwd }: {
+	cwd: string;
+}): Promise<{
+	exists: boolean;
+	options: HanzoguiOptions;
+}>;
+
+//# sourceMappingURL=readHanzoguiOptions.d.ts.map

package/types/readHanzoguiOptions.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAEA,cAAc,uBAAuB;AAKrC,OAAO,iBAAe,oBAAoB,EAAE,OAAa;CAAE;IAAgB,QAAQ;CACjF;CACA,SAAS",
+  "names": [],
+  "sources": [
+    "src/readHanzoguiOptions.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { join } from 'node:path'\n\nimport type { HanzoguiOptions } from '@hanzogui/types'\nimport { pathExists, readJSON } from 'fs-extra'\n\nimport { getDefaultHanzoguiOptions } from './getDefaultHanzoguiOptions'\n\nexport async function readHanzoguiOptions({ cwd = '.' }: { cwd: string }): Promise<{\n  exists: boolean\n  options: HanzoguiOptions\n}> {\n  const filePath = join(cwd, 'hanzogui.json')\n\n  if (!(await pathExists(filePath))) {\n    return {\n      exists: false,\n      options: await getDefaultHanzoguiOptions({ cwd }),\n    }\n  }\n\n  try {\n    const options = (await readJSON(filePath)) as HanzoguiOptions\n\n    if (!Array.isArray(options.components)) {\n      throw new Error(`Invalid components: not string[]`)\n    }\n\n    return {\n      exists: true,\n      options: {\n        ...(!options.config && (await getDefaultHanzoguiOptions({ cwd }))),\n        ...options,\n      },\n    }\n  } catch (err: any) {\n    console.error(`Error reading hanzogui.json: ${err.message} ${err.stack}`)\n\n    return {\n      exists: false,\n      options: await getDefaultHanzoguiOptions({ cwd }),\n    }\n  }\n}\n"
+  ]
+}