@tamagui/helpers-node 1.0.1-beta.161

package/dist/getDefaultTamaguiOptions.js

@@ -0,0 +1,37 @@
+"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 getDefaultTamaguiOptions_exports = {};
+__export(getDefaultTamaguiOptions_exports, {
+  getDefaultTamaguiOptions: () => getDefaultTamaguiOptions
+});
+module.exports = __toCommonJS(getDefaultTamaguiOptions_exports);
+var import_getTamaguiDefaultPath = require("./getTamaguiDefaultPath");
+async function getDefaultTamaguiOptions({
+  cwd = "."
+}) {
+  return {
+    components: ["tamagui"],
+    config: await (0, import_getTamaguiDefaultPath.getDefaultTamaguiConfigPath)({ cwd })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultTamaguiOptions
+});
+//# sourceMappingURL=getDefaultTamaguiOptions.js.map

package/dist/getDefaultTamaguiOptions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/getDefaultTamaguiOptions.ts"],
+  "sourcesContent": ["import { getDefaultTamaguiConfigPath } from './getTamaguiDefaultPath'\nimport type { TamaguiOptions } from './types'\n\nexport async function getDefaultTamaguiOptions({\n  cwd = '.',\n}: {\n  cwd: string\n}): Promise<TamaguiOptions> {\n  return {\n    components: ['tamagui'],\n    config: await getDefaultTamaguiConfigPath({ cwd }),\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mCAA4C;AAG5C,eAAsB,yBAAyB;AAAA,EAC7C,MAAM;AACR,GAE4B;AAC1B,SAAO;AAAA,IACL,YAAY,CAAC,SAAS;AAAA,IACtB,QAAQ,UAAM,0DAA4B,EAAE,IAAI,CAAC;AAAA,EACnD;AACF;",
+  "names": []
+}

package/dist/getTamaguiDefaultPath.js

@@ -0,0 +1,51 @@
+"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 getTamaguiDefaultPath_exports = {};
+__export(getTamaguiDefaultPath_exports, {
+  getDefaultTamaguiConfigPath: () => getDefaultTamaguiConfigPath
+});
+module.exports = __toCommonJS(getTamaguiDefaultPath_exports);
+var import_path = require("path");
+var import_fs_extra = require("fs-extra");
+let cachedPath = "";
+async function getDefaultTamaguiConfigPath({
+  cwd = ".",
+  cache = true
+}) {
+  if (cache && cachedPath) {
+    return cachedPath;
+  }
+  const defaultPaths = ["tamagui.config.ts", (0, import_path.join)("src", "tamagui.config.ts")].map(
+    (p) => (0, import_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 tamagui.config.ts`);
+  }
+  cachedPath = found;
+  return found;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultTamaguiConfigPath
+});
+//# sourceMappingURL=getTamaguiDefaultPath.js.map

package/dist/getTamaguiDefaultPath.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/getTamaguiDefaultPath.ts"],
+  "sourcesContent": ["import { join } from 'path'\n\nimport { pathExists } from 'fs-extra'\n\nlet cachedPath = ''\n\nexport async function getDefaultTamaguiConfigPath({\n  cwd = '.',\n  cache = true,\n}: {\n  cwd?: string\n  // TODO this isn't passed down / could avoid\n  cache?: boolean\n}) {\n  if (cache && cachedPath) {\n    return cachedPath\n  }\n\n  const defaultPaths = ['tamagui.config.ts', join('src', 'tamagui.config.ts')].map((p) =>\n    join(cwd, p)\n  )\n  const existing = (await Promise.all(defaultPaths.map((path) => pathExists(path)))).findIndex(\n    (x) => !!x\n  )\n  const found = defaultPaths[existing]\n  if (!found) {\n    throw new Error(`No found tamagui.config.ts`)\n  }\n\n  cachedPath = found\n  return found\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB;AAErB,sBAA2B;AAE3B,IAAI,aAAa;AAEjB,eAAsB,4BAA4B;AAAA,EAChD,MAAM;AAAA,EACN,QAAQ;AACV,GAIG;AACD,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,CAAC,yBAAqB,kBAAK,OAAO,mBAAmB,CAAC,EAAE;AAAA,IAAI,CAAC,UAChF,kBAAK,KAAK,CAAC;AAAA,EACb;AACA,QAAM,YAAY,MAAM,QAAQ,IAAI,aAAa,IAAI,CAAC,aAAS,4BAAW,IAAI,CAAC,CAAC,GAAG;AAAA,IACjF,CAAC,MAAM,CAAC,CAAC;AAAA,EACX;AACA,QAAM,QAAQ,aAAa;AAC3B,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAC9C;AAEA,eAAa;AACb,SAAO;AACT;",
+  "names": []
+}

package/dist/getTamaguiOptions.js

@@ -0,0 +1,32 @@
+"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 getTamaguiOptions_exports = {};
+__export(getTamaguiOptions_exports, {
+  getTamaguiOptions: () => getTamaguiOptions
+});
+module.exports = __toCommonJS(getTamaguiOptions_exports);
+var import_readTamaguiOptions = require("./readTamaguiOptions");
+async function getTamaguiOptions({ cwd = "." }) {
+  return (await (0, import_readTamaguiOptions.readTamaguiOptions)({ cwd })).options;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTamaguiOptions
+});
+//# sourceMappingURL=getTamaguiOptions.js.map

package/dist/getTamaguiOptions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/getTamaguiOptions.ts"],
+  "sourcesContent": ["import { readTamaguiOptions } from './readTamaguiOptions'\n\nexport async function getTamaguiOptions({ cwd = '.' }: { cwd?: string }) {\n  return (await readTamaguiOptions({ cwd })).options\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAAmC;AAEnC,eAAsB,kBAAkB,EAAE,MAAM,IAAI,GAAqB;AACvE,UAAQ,UAAM,8CAAmB,EAAE,IAAI,CAAC,GAAG;AAC7C;",
+  "names": []
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+"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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./readTamaguiOptions"), module.exports);
+__reExport(src_exports, require("./getTamaguiDefaultPath"), module.exports);
+__reExport(src_exports, require("./getTamaguiOptions"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export * from './readTamaguiOptions'\nexport * from './getTamaguiDefaultPath'\nexport * from './getTamaguiOptions'\nexport * from './types'\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,wBAAc,iCAAd;AACA,wBAAc,oCADd;AAEA,wBAAc,gCAFd;AAGA,wBAAc,oBAHd;",
+  "names": []
+}

package/dist/readTamaguiJSON.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=readTamaguiJSON.js.map

package/dist/readTamaguiJSON.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/readTamaguiOptions.js

@@ -0,0 +1,59 @@
+"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 readTamaguiOptions_exports = {};
+__export(readTamaguiOptions_exports, {
+  readTamaguiOptions: () => readTamaguiOptions
+});
+module.exports = __toCommonJS(readTamaguiOptions_exports);
+var import_path = require("path");
+var import_fs_extra = require("fs-extra");
+var import_getDefaultTamaguiOptions = require("./getDefaultTamaguiOptions");
+async function readTamaguiOptions({ cwd = "." }) {
+  const filePath = (0, import_path.join)(cwd, "tamagui.json");
+  if (!await (0, import_fs_extra.pathExists)(filePath)) {
+    return {
+      exists: false,
+      options: await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({ 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_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({ cwd }),
+        ...options
+      }
+    };
+  } catch (err) {
+    console.error(`Error reading tamagui.json: ${err.message} ${err.stack}`);
+    return {
+      exists: false,
+      options: await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({ cwd })
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readTamaguiOptions
+});
+//# sourceMappingURL=readTamaguiOptions.js.map

package/dist/readTamaguiOptions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/readTamaguiOptions.ts"],
+  "sourcesContent": ["import { join } from 'path'\n\nimport { pathExists, readJSON } from 'fs-extra'\n\nimport { getDefaultTamaguiOptions } from './getDefaultTamaguiOptions'\nimport type { TamaguiOptions } from './types'\n\nexport async function readTamaguiOptions({ cwd = '.' }: { cwd: string }) {\n  const filePath = join(cwd, 'tamagui.json')\n\n  if (!(await pathExists(filePath))) {\n    return {\n      exists: false,\n      options: await getDefaultTamaguiOptions({ cwd }),\n    }\n  }\n\n  try {\n    const options = (await readJSON(filePath)) as TamaguiOptions\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 getDefaultTamaguiOptions({ cwd }))),\n        ...options,\n      },\n    }\n  } catch (err: any) {\n    // eslint-disable-next-line no-console\n    console.error(`Error reading tamagui.json: ${err.message} ${err.stack}`)\n\n    return {\n      exists: false,\n      options: await getDefaultTamaguiOptions({ cwd }),\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB;AAErB,sBAAqC;AAErC,sCAAyC;AAGzC,eAAsB,mBAAmB,EAAE,MAAM,IAAI,GAAoB;AACvE,QAAM,eAAW,kBAAK,KAAK,cAAc;AAEzC,MAAI,CAAE,UAAM,4BAAW,QAAQ,GAAI;AACjC,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,IACjD;AAAA,EACF;AAEA,MAAI;AACF,UAAM,UAAW,UAAM,0BAAS,QAAQ;AAExC,QAAI,CAAC,MAAM,QAAQ,QAAQ,UAAU,GAAG;AACtC,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AAEA,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS;AAAA,QACP,GAAI,CAAC,QAAQ,UAAW,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,QAC9D,GAAG;AAAA,MACL;AAAA,IACF;AAAA,EACF,SAAS,KAAP;AAEA,YAAQ,MAAM,+BAA+B,IAAI,WAAW,IAAI,OAAO;AAEvE,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,IACjD;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/types.js

@@ -0,0 +1,17 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts"],
+  "sourcesContent": ["export interface TamaguiOptions {\n  // module paths you want to compile with tamagui (for example ['tamagui'])\n  components: string[]\n  // your tamagui.config.ts\n  config?: string\n  evaluateVars?: boolean\n  importsWhitelist?: string[]\n  disable?: boolean\n  disableExtraction?: boolean\n  disableDebugAttr?: boolean\n  disableExtractInlineMedia?: boolean\n  disableExtractVariables?: boolean\n  excludeReactNativeWebExports?: string[]\n  exclude?: RegExp\n  logTimings?: boolean\n  prefixLogs?: string\n\n  // probably non user options\n  cssPath?: string\n  cssData?: any\n  deoptProps?: Set<string>\n  excludeProps?: Set<string>\n  inlineProps?: Set<string>\n  forceExtractStyleDefinitions?: boolean\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@tamagui/helpers-node",
+  "version": "1.0.1-beta.161",
+  "source": "src/index.ts",
+  "types": "./types/index.d.ts",
+  "main": "./dist",
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tamagui-build",
+    "watch": "tamagui-build --watch",
+    "clean": "tamagui-build clean",
+    "clean:build": "tamagui-build clean:build"
+  },
+  "devDependencies": {
+    "@tamagui/build": "^1.0.1-beta.161",
+    "fs-extra": "^10.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/getDefaultTamaguiOptions.ts

@@ -0,0 +1,13 @@
+import { getDefaultTamaguiConfigPath } from './getTamaguiDefaultPath'
+import type { TamaguiOptions } from './types'
+
+export async function getDefaultTamaguiOptions({
+  cwd = '.',
+}: {
+  cwd: string
+}): Promise<TamaguiOptions> {
+  return {
+    components: ['tamagui'],
+    config: await getDefaultTamaguiConfigPath({ cwd }),
+  }
+}

package/src/getTamaguiDefaultPath.ts

@@ -0,0 +1,32 @@
+import { join } from 'path'
+
+import { pathExists } from 'fs-extra'
+
+let cachedPath = ''
+
+export async function getDefaultTamaguiConfigPath({
+  cwd = '.',
+  cache = true,
+}: {
+  cwd?: string
+  // TODO this isn't passed down / could avoid
+  cache?: boolean
+}) {
+  if (cache && cachedPath) {
+    return cachedPath
+  }
+
+  const defaultPaths = ['tamagui.config.ts', join('src', 'tamagui.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 tamagui.config.ts`)
+  }
+
+  cachedPath = found
+  return found
+}

package/src/getTamaguiOptions.ts

@@ -0,0 +1,5 @@
+import { readTamaguiOptions } from './readTamaguiOptions'
+
+export async function getTamaguiOptions({ cwd = '.' }: { cwd?: string }) {
+  return (await readTamaguiOptions({ cwd })).options
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './readTamaguiOptions'
+export * from './getTamaguiDefaultPath'
+export * from './getTamaguiOptions'
+export * from './types'

package/src/readTamaguiOptions.ts

@@ -0,0 +1,41 @@
+import { join } from 'path'
+
+import { pathExists, readJSON } from 'fs-extra'
+
+import { getDefaultTamaguiOptions } from './getDefaultTamaguiOptions'
+import type { TamaguiOptions } from './types'
+
+export async function readTamaguiOptions({ cwd = '.' }: { cwd: string }) {
+  const filePath = join(cwd, 'tamagui.json')
+
+  if (!(await pathExists(filePath))) {
+    return {
+      exists: false,
+      options: await getDefaultTamaguiOptions({ cwd }),
+    }
+  }
+
+  try {
+    const options = (await readJSON(filePath)) as TamaguiOptions
+
+    if (!Array.isArray(options.components)) {
+      throw new Error(`Invalid components: not string[]`)
+    }
+
+    return {
+      exists: true,
+      options: {
+        ...(!options.config && (await getDefaultTamaguiOptions({ cwd }))),
+        ...options,
+      },
+    }
+  } catch (err: any) {
+    // eslint-disable-next-line no-console
+    console.error(`Error reading tamagui.json: ${err.message} ${err.stack}`)
+
+    return {
+      exists: false,
+      options: await getDefaultTamaguiOptions({ cwd }),
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,25 @@
+export interface TamaguiOptions {
+  // module paths you want to compile with tamagui (for example ['tamagui'])
+  components: string[]
+  // your tamagui.config.ts
+  config?: string
+  evaluateVars?: boolean
+  importsWhitelist?: string[]
+  disable?: boolean
+  disableExtraction?: boolean
+  disableDebugAttr?: boolean
+  disableExtractInlineMedia?: boolean
+  disableExtractVariables?: boolean
+  excludeReactNativeWebExports?: string[]
+  exclude?: RegExp
+  logTimings?: boolean
+  prefixLogs?: string
+
+  // probably non user options
+  cssPath?: string
+  cssData?: any
+  deoptProps?: Set<string>
+  excludeProps?: Set<string>
+  inlineProps?: Set<string>
+  forceExtractStyleDefinitions?: boolean
+}

package/types/getDefaultTamaguiConfig.d.ts

@@ -0,0 +1,10 @@
+export declare function getDefaultTamaguiConfig({ cwd }: {
+    cwd: string;
+}): Promise<{
+    exists: boolean;
+    config: {
+        components: string[];
+        config: string;
+    };
+}>;
+//# sourceMappingURL=getDefaultTamaguiConfig.d.ts.map

package/types/getDefaultTamaguiOptions.d.ts

@@ -0,0 +1,5 @@
+import type { TamaguiOptions } from './types';
+export declare function getDefaultTamaguiOptions({ cwd, }: {
+    cwd: string;
+}): Promise<TamaguiOptions>;
+//# sourceMappingURL=getDefaultTamaguiOptions.d.ts.map

package/types/getTamaguiDefaultPath.d.ts

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

package/types/getTamaguiOptions.d.ts

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

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './readTamaguiOptions';
+export * from './getTamaguiDefaultPath';
+export * from './getTamaguiOptions';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/types/readTamaguiJSON.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=readTamaguiJSON.d.ts.map

package/types/readTamaguiOptions.d.ts

@@ -0,0 +1,8 @@
+import type { TamaguiOptions } from './types';
+export declare function readTamaguiOptions({ cwd }: {
+    cwd: string;
+}): Promise<{
+    exists: boolean;
+    options: TamaguiOptions;
+}>;
+//# sourceMappingURL=readTamaguiOptions.d.ts.map

package/types/types.d.ts

@@ -0,0 +1,22 @@
+export interface TamaguiOptions {
+    components: string[];
+    config?: string;
+    evaluateVars?: boolean;
+    importsWhitelist?: string[];
+    disable?: boolean;
+    disableExtraction?: boolean;
+    disableDebugAttr?: boolean;
+    disableExtractInlineMedia?: boolean;
+    disableExtractVariables?: boolean;
+    excludeReactNativeWebExports?: string[];
+    exclude?: RegExp;
+    logTimings?: boolean;
+    prefixLogs?: string;
+    cssPath?: string;
+    cssData?: any;
+    deoptProps?: Set<string>;
+    excludeProps?: Set<string>;
+    inlineProps?: Set<string>;
+    forceExtractStyleDefinitions?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map