@tamagui/generate-themes 1.88.12 → 1.89.0-1706308641099

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/esm/generate-themes.mjs

@@ -0,0 +1,161 @@
+import Module from "module";
+import { join } from "path";
+const ogRequire = Module.prototype.require;
+async function generateThemes(inputFile) {
+  const {
+      unregister
+    } = require("esbuild-register/dist/node").register({
+      hookIgnoreNodeModules: !1
+    }),
+    inputFilePath = inputFile[0] === "." ? join(process.cwd(), inputFile) : inputFile;
+  purgeCache(inputFilePath);
+  let promise = null;
+  Module.prototype.require = function (id) {
+    const out = ogRequire.apply(this, arguments);
+    if (id === "@tamagui/theme-builder" && !promise) {
+      let resolve;
+      return promise = new Promise(res => {
+        resolve = res;
+      }), createThemeIntercept(out, {
+        onComplete: result => {
+          resolve?.(result.themeBuilder);
+        }
+      });
+    }
+    return out;
+  };
+  try {
+    const requiredThemes = require(inputFilePath),
+      themes = requiredThemes.default || requiredThemes.themes,
+      generatedThemes = generatedThemesToTypescript(themes);
+    let tm;
+    if (promise) {
+      let finished = !1;
+      promise.then(() => {
+        finished = !0;
+      }), tm = setTimeout(() => {
+        finished || console.warn("Warning: ThemeBuilder didn't finish after a couple seconds, did you forget to call .build()?");
+      }, 2e3);
+    }
+    const themeBuilder = promise ? await promise : null;
+    return clearTimeout(tm), {
+      generated: generatedThemes,
+      state: themeBuilder?.state
+    };
+  } catch (err) {
+    console.warn(` \u26A0\uFE0F Error running theme builder: ${err}`, err?.stack);
+  } finally {
+    Module.prototype.require = ogRequire, unregister();
+  }
+}
+const dedupedTokens = /* @__PURE__ */new Map();
+function generatedThemesToTypescript(themes) {
+  const dedupedThemes = /* @__PURE__ */new Map(),
+    dedupedThemeToNames = /* @__PURE__ */new Map();
+  let i = 0;
+  for (const name in themes) {
+    i++;
+    const theme = themes[name];
+    let j = 0;
+    for (const [key2, value] of Object.entries(theme)) {
+      i++;
+      const uniqueKey = `t${i}${j}`;
+      dedupedTokens.has(value) || dedupedTokens.set(value, uniqueKey);
+    }
+    const key = JSON.stringify(theme);
+    dedupedThemes.has(key) ? dedupedThemeToNames.set(key, [...dedupedThemeToNames.get(key), name]) : (dedupedThemes.set(key, theme), dedupedThemeToNames.set(key, [name]));
+  }
+  const baseKeys = Object.entries(themes.light || themes[Object.keys(themes)[0]]);
+  let out = `${`type Theme = {
+${baseKeys.map(([k]) => `  ${k}: string;
+`).join("")}
+}`}
+`;
+  out += `
+function t(a: [number, number][]) {
+  let res: Record<string,string> = {}
+  for (const [ki, vi] of a) {
+    res[ks[ki] as string] = vs[vi] as string
+  }
+  return res as Theme
+}
+`, out += `const vs = [
+`;
+  let index = 0;
+  const valueToIndex = {};
+  dedupedTokens.forEach((name, value) => {
+    valueToIndex[value] = index, index++, out += `  '${value}',
+`;
+  }), out += `]
+
+`;
+  const keys = baseKeys.map(([k]) => k);
+  out += `const ks = [
+`, out += keys.map(k => `'${k}'`).join(`,
+`), out += `]
+
+`;
+  let nameI = 0;
+  return dedupedThemes.forEach(theme => {
+    nameI++;
+    const key = JSON.stringify(theme),
+      names = dedupedThemeToNames.get(key),
+      name = `n${nameI}`,
+      baseTheme = `const ${name} = ${objectToJsString(theme, keys, valueToIndex)}`;
+    out += `
+${baseTheme}`;
+    const duplicateThemes = names.map(n => `export const ${n} = ${name}`);
+    out += `
+
+` + duplicateThemes.join(`
+`);
+  }), out;
+}
+function objectToJsString(obj, keys, valueToIndex) {
+  let arrItems = [];
+  for (const key in obj) {
+    const ki = keys.indexOf(key),
+      vi = valueToIndex[obj[key]];
+    arrItems.push(`[${ki}, ${vi}]`);
+  }
+  return `t([${arrItems.join(",")}])`;
+}
+function createThemeIntercept(createThemeExport, themeBuilderInterceptOpts) {
+  return new Proxy(createThemeExport, {
+    get(target, key) {
+      const out = Reflect.get(target, key);
+      return key === "createThemeBuilder" ? new Proxy(out, {
+        apply(target2, thisArg, argArray) {
+          const builder = Reflect.apply(target2, thisArg, argArray);
+          return themeBuilderIntercept(builder, themeBuilderInterceptOpts);
+        }
+      }) : out;
+    }
+  });
+}
+function themeBuilderIntercept(themeBuilder, themeBuilderInterceptOpts) {
+  return new Proxy(themeBuilder, {
+    get(target, key) {
+      const out = Reflect.get(target, key);
+      return key === "build" && themeBuilderInterceptOpts.onComplete({
+        themeBuilder
+      }), out;
+    }
+  });
+}
+function purgeCache(moduleName) {
+  searchCache(moduleName, function (mod) {
+    delete require.cache[mod.id];
+  }), Object.keys(module.constructor._pathCache).forEach(function (cacheKey) {
+    cacheKey.indexOf(moduleName) > 0 && delete module.constructor._pathCache[cacheKey];
+  });
+}
+function searchCache(moduleName, callback) {
+  let mod = require.resolve(moduleName);
+  mod && (mod = require.cache[mod]) !== void 0 && function traverse(mod2, depth = 0) {
+    depth > 10 || (mod2.children.forEach(function (child) {
+      traverse(child, depth + 1);
+    }), callback(mod2));
+  }(mod);
+}
+export { generateThemes };

package/dist/esm/index.mjs

@@ -0,0 +1,2 @@
+export * from "./generate-themes.mjs";
+export * from "./write-generate-themes.mjs";

package/dist/esm/write-generate-themes.mjs

@@ -0,0 +1,16 @@
+import { join } from "path";
+import * as fs from "fs-extra";
+async function writeGeneratedThemes(tamaguiDotDir, outPath, generatedOutput) {
+  if (!generatedOutput) return;
+  const {
+      generated,
+      state
+    } = generatedOutput,
+    tamaguiDotDirExists = await fs.pathExists(tamaguiDotDir),
+    themeBuilderStatePath = join(tamaguiDotDir, "theme-builder.json");
+  process.env.DEBUG === "tamagui" && (console.info("Generated themes:", JSON.stringify(generatedOutput, null, 2)), console.info("Writing themes to", {
+    outPath,
+    themeBuilderStatePath
+  })), await Promise.all([fs.writeFile(outPath, generated), state && tamaguiDotDirExists ? fs.writeFile(themeBuilderStatePath, JSON.stringify(state)) : null]);
+}
+export { writeGeneratedThemes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/generate-themes",
-  "version": "1.88.12",
+  "version": "1.89.0-1706308641099",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
@@ -29,12 +29,12 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/create-theme": "1.88.12",
-    "@tamagui/types": "1.88.12",
+    "@tamagui/create-theme": "1.89.0-1706308641099",
+    "@tamagui/types": "1.89.0-1706308641099",
     "esbuild-register": "^3.4.2",
-    "fs-extra": "^11.1.0"
+    "fs-extra": "^11.2.0"
   },
   "devDependencies": {
-    "@tamagui/build": "1.88.12"
+    "@tamagui/build": "1.89.0-1706308641099"
   }
 }