tamagui-loader 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/TamaguiPlugin.mjs

@@ -0,0 +1,168 @@
+import { existsSync } from "fs";
+import path, { dirname, join } from "path";
+import { loadTamagui, watchTamaguiConfig } from "@tamagui/static";
+import buildResolver from "esm-resolve";
+import webpack from "webpack";
+import { shouldExclude } from "./shouldExclude.mjs";
+const dir = process.cwd(),
+  resolver = buildResolver(join(dir, "index.js"), {
+    constraints: "node"
+  });
+class TamaguiPlugin {
+  constructor(options = {
+    platform: "web",
+    components: ["@tamagui/core"]
+  }) {
+    this.options = options;
+  }
+  pluginName = "TamaguiPlugin";
+  resolveEsm = (relativePath, onlyRequire = !1) => {
+    if (this.options.isServer || onlyRequire) return require.resolve(relativePath);
+    const esm = resolver(relativePath);
+    return esm ? path.join(dir, esm) : require.resolve(relativePath);
+  };
+  safeResolves = (resolves, multiple = !1) => {
+    const res = [];
+    for (const [out, mod] of resolves) {
+      if (out.endsWith("$")) {
+        res.push([out, mod]);
+        continue;
+      }
+      try {
+        res.push([out, this.resolveEsm(mod)]), multiple && res.push([out, this.resolveEsm(mod, !0)]);
+      } catch (err) {
+        if (out.includes("@gorhom/bottom-sheet")) continue;
+        process.env.DEBUG?.startsWith("tamagui") && console.info(`  withTamagui skipping resolving ${out}`, err);
+      }
+    }
+    return res;
+  };
+  get componentsFullPaths() {
+    return this.safeResolves(this.options.components.map(moduleName => [moduleName, moduleName]), !0);
+  }
+  get componentsBaseDirs() {
+    return this.componentsFullPaths.map(([_, fullPath]) => {
+      let rootPath = dirname(fullPath);
+      for (; rootPath.length > 1;) {
+        const pkg = join(rootPath, "package.json");
+        if (existsSync(pkg)) return rootPath;
+        rootPath = join(rootPath, "..");
+      }
+      throw new Error(`Couldn't find package.json in any path above: ${fullPath}`);
+    });
+  }
+  isInComponentModule = fullPath => this.componentsBaseDirs.some(componentDir => fullPath.startsWith(componentDir));
+  get defaultAliases() {
+    return Object.fromEntries(this.safeResolves([["@tamagui/core/reset.css", "@tamagui/core/reset.css"], ["@tamagui/core", "@tamagui/core"], ["@tamagui/web", "@tamagui/web"],
+    // web specific light react-native-svg, optional, can use svgs but had issues with compat
+    ["react-native-svg", "@tamagui/react-native-svg"],
+    // fixes https://github.com/kentcdodds/mdx-bundler/issues/143
+    ["react/jsx-runtime.js", "react/jsx-runtime"], ["react/jsx-runtime", "react/jsx-runtime"], ["react/jsx-dev-runtime.js", "react/jsx-dev-runtime"], ["react/jsx-dev-runtime", "react/jsx-dev-runtime"], ["react-native-reanimated", "react-native-reanimated"], ["@testing-library/react-native", "@tamagui/proxy-worm"], ["@gorhom/bottom-sheet$", "@gorhom/bottom-sheet"],
+    // fix reanimated 3
+    ["react-native/Libraries/Renderer/shims/ReactFabric", "@tamagui/proxy-worm"],
+    // @ts-expect-error deprecated
+    ...(this.options.useReactNativeWebLite ? [["react-native$", "react-native-web-lite"], ["react-native-web$", "react-native-web-lite"]] : [["react-native$", "react-native-web"], ["react-native-web$", "react-native-web"]])]));
+  }
+  apply(compiler) {
+    if (compiler.watchMode && !this.options.disableWatchConfig && watchTamaguiConfig(this.options).then(watcher => {
+      process.once("exit", () => {
+        watcher.dispose();
+      });
+    }), this.options.exclude || (this.options.exclude = path2 => this.isInComponentModule(path2) ? !1 : shouldExclude(path2)), compiler.hooks.beforeRun.tapPromise(this.pluginName, async () => {
+      await loadTamagui(this.options);
+    }), compiler.hooks.normalModuleFactory.tap(this.pluginName, nmf => {
+      nmf.hooks.createModule.tap(this.pluginName,
+      // @ts-expect-error CreateData is typed as 'object'...
+      createData => {
+        createData.matchResource?.endsWith(".tamagui.css") && (createData.settings.sideEffects = !0);
+      });
+    }), !this.options.disableAliases) {
+      const existingAlias = compiler.options.resolve.alias;
+      Array.isArray(existingAlias) || typeof existingAlias == "object" && Object.assign(existingAlias, this.defaultAliases);
+    }
+    const excludeExports = this.options.excludeReactNativeWebExports;
+    if (excludeExports && Array.isArray(excludeExports)) try {
+      const regexStr = `react-native-web(-lite)?/.*(${excludeExports.join("|")}).*js`,
+        regex = new RegExp(regexStr);
+      compiler.hooks.environment.tap("MyPlugin", () => {
+        new webpack.NormalModuleReplacementPlugin(regex, this.resolveEsm("@tamagui/proxy-worm")).apply(compiler);
+      });
+    } catch {
+      console.warn(`Invalid names provided to excludeReactNativeWebExports: ${excludeExports.join(", ")}`);
+    }
+    this.options.emitSingleCSSFile && (console.info("    \u27A1 [tamagui] \u{1F3A8} combining css into one file"), compiler.hooks.make.tap(this.pluginName, compilation => {
+      compilation.hooks.processAssets.tap(this.pluginName, assets => {
+        try {
+          const cssFiles = Object.keys(assets).filter(asset => asset.endsWith(".css"));
+          if (cssFiles.length === 0) return;
+          const combinedCSS = cssFiles.reduce((acc, file) => {
+            const cssContent = compilation.assets[file].source();
+            return `${acc}
+${cssContent}`;
+          }, "");
+          for (const [index, cssFile] of cssFiles.entries()) index > 0 ? compilation.updateAsset(cssFile, new compiler.webpack.sources.RawSource("")) : (console.info(`    \u27A1 [tamagui] \u{1F3A8} emitting single css to ${cssFile}`), compilation.updateAsset(cssFile, new compiler.webpack.sources.RawSource(Buffer.from(combinedCSS))));
+        } catch (error) {
+          compilation.errors.push(error);
+        }
+      });
+    })), compiler.options.resolve.extensions = [... /* @__PURE__ */new Set([".web.tsx", ".web.ts", ".web.js", ".ts", ".tsx", ".js", ...(compiler.options.resolve.extensions || [])])];
+    const mainFields = compiler.options.resolve.mainFields;
+    if (mainFields && (compiler.options.resolve.mainFields = Array.isArray(mainFields) ? mainFields : [mainFields], this.options.disableModuleJSXEntry || mainFields.unshift("module:jsx")), !compiler.options.module) return;
+    const {
+        jsLoader
+      } = this.options,
+      existing = compiler.options.module.rules,
+      rules = existing.find(x => typeof x == "object" && "oneOf" in x ? x : null)?.oneOf ?? existing,
+      nextJsRules = rules.findIndex(x => x?.use && x.use.loader === "next-swc-loader" && x.issuerLayer !== "api"),
+      esbuildLoader = {
+        loader: require.resolve("esbuild-loader"),
+        options: {
+          target: "es2021",
+          keepNames: !0,
+          loader: "tsx",
+          tsconfigRaw: {
+            module: this.options.isServer ? "commonjs" : "esnext",
+            isolatedModules: !0,
+            resolveJsonModule: !0
+          }
+        }
+      };
+    if (!this.options.disable) {
+      const tamaguiLoader = {
+        loader: require.resolve("tamagui-loader"),
+        options: {
+          ...this.options,
+          _disableLoadTamagui: !0
+        }
+      };
+      if (nextJsRules === -1) existing.push({
+        // looks like its in jsx dir (could be better but windows path sep)
+        test: /jsx.*\.m?[jt]sx?$/,
+        exclude: this.options.exclude,
+        resolve: {
+          fullySpecified: !1
+        },
+        use: [esbuildLoader]
+      }), existing.push({
+        test: this.options.test ?? /\.m?[jt]sx?$/,
+        exclude: this.options.exclude,
+        resolve: {
+          fullySpecified: !1
+        },
+        use: [tamaguiLoader]
+      });else if (!this.options.disableEsbuildLoader) {
+        const startIndex = nextJsRules ? nextJsRules + 1 : 0,
+          existingLoader = nextJsRules ? rules[startIndex] : void 0;
+        rules.splice(startIndex, 0, {
+          test: this.options.test ?? /\.m?[jt]sx?$/,
+          exclude: this.options.exclude,
+          resolve: {
+            fullySpecified: !1
+          },
+          use: [...(jsLoader ? [jsLoader] : []), ...(existingLoader && nextJsRules ? [].concat(existingLoader.use) : []), ...(jsLoader || existingLoader ? [] : [esbuildLoader]), tamaguiLoader]
+        });
+      }
+    }
+  }
+}
+export { TamaguiPlugin };

package/dist/esm/css.mjs

@@ -0,0 +1,13 @@
+function loader() {
+  this.async();
+  const options = {
+    ...this.getOptions()
+  };
+  let out = Buffer.from(options.cssData, "base64").toString("utf-8");
+  if (out) return this.callback(null, out || "");
+  this.callback({
+    message: "No CSS found",
+    name: "missing_css"
+  });
+}
+export { loader as default };

package/dist/esm/index.mjs

@@ -0,0 +1,7 @@
+export * from "./TamaguiPlugin.mjs";
+export * from "./shouldExclude.mjs";
+process.env.TAMAGUI_TARGET = "web";
+process.env.IS_STATIC = "is_static";
+process.env.TAMAGUI_IS_SERVER = "true";
+var src_default = require("./loader").loader;
+export { src_default as default };

package/dist/esm/loader.mjs

@@ -0,0 +1,57 @@
+import { createExtractor, extractToClassNames, getPragmaOptions } from "@tamagui/static";
+Error.stackTraceLimit = 1 / 0;
+const CSS_LOADER_PATH = require.resolve("./css");
+Error.stackTraceLimit = 1 / 0;
+const extractor = createExtractor();
+let index = 0;
+process.env.TAMAGUI_TARGET = "web";
+const loader = async function (sourceIn) {
+  this.cacheable(!0);
+  const callback = this.async(),
+    source = sourceIn.toString();
+  try {
+    const options = {
+        // @ts-ignore
+        platform: "web",
+        ...this.getOptions()
+      },
+      sourcePath = `${this.resourcePath}`,
+      {
+        shouldDisable,
+        shouldPrintDebug
+      } = getPragmaOptions({
+        source,
+        path: sourcePath
+      });
+    if (shouldPrintDebug === "verbose" && (console.warn(`
+
+ --- Incoming source --- 
+
+`), console.warn(source)), shouldDisable) return shouldPrintDebug && console.info("Disabling on file via pragma"), callback(null, source);
+    const cssPath = `${sourcePath}.${index++}.tamagui.css`,
+      extracted = await extractToClassNames({
+        extractor,
+        source,
+        sourcePath,
+        options,
+        shouldPrintDebug
+      });
+    if (!extracted) return callback(null, source);
+    if (extracted.styles) {
+      const cssQuery = `cssData=${Buffer.from(extracted.styles).toString("base64")}`,
+        remReq = this.remainingRequest,
+        importPath = `${cssPath}!=!${CSS_LOADER_PATH}?${cssQuery}!${remReq}`;
+      extracted.js = `${extracted.js}
+
+require(${JSON.stringify(importPath)})`;
+    }
+    callback(null, extracted.js, extracted.map);
+  } catch (err) {
+    const message = err instanceof Error ? `${err.message}
+${err.stack}` : String(err);
+    console.error(`Tamagui Webpack Loader Error:
+`, `  ${message}
+`), message.includes("Cannot create proxy") && console.info("This is usually due to components not loading at build-time. Check for logs just below the line above:"), callback(null, source);
+  }
+};
+export { loader };

package/dist/esm/shouldExclude.mjs

@@ -0,0 +1,6 @@
+import path from "path";
+const shouldExclude = (filePath, projectRoot) => !(projectRoot && filePath.includes(projectRoot) && filePath.endsWith("sx") || isTamaguiDistJSX(filePath));
+function isTamaguiDistJSX(filePath) {
+  return filePath.includes("/dist/jsx/".replace(/\//g, path.sep));
+}
+export { shouldExclude };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamagui-loader",
-  "version": "1.88.12",
+  "version": "1.89.0-1706308641099",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
   "module": "dist/esm",
@@ -18,18 +18,18 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/cli-color": "1.88.12",
-    "@tamagui/core": "1.88.12",
-    "@tamagui/static": "1.88.12",
-    "@tamagui/web": "1.88.12",
+    "@tamagui/cli-color": "1.89.0-1706308641099",
+    "@tamagui/core": "1.89.0-1706308641099",
+    "@tamagui/static": "1.89.0-1706308641099",
+    "@tamagui/web": "1.89.0-1706308641099",
     "esbuild-loader": "^3.0.1",
     "esm-resolve": "^1.0.8",
-    "fs-extra": "^11.1.0",
+    "fs-extra": "^11.2.0",
     "loader-utils": "^3.2.1",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@tamagui/build": "1.88.12",
+    "@tamagui/build": "1.89.0-1706308641099",
     "prettyjson": "^1.2.5",
     "webpack": "^5.88.2"
   },