gt 2.14.35 → 2.14.36

package/dist/react/config/createESBuildConfig.js

@@ -1,119 +1,119 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { displayResolvedPaths } from '../../console/logging.js';
-export default function createESBuildConfig(config = {}) {
-    const esbuildOptions = {
-        bundle: true,
-        format: 'cjs',
-        platform: 'node',
-        target: 'es2021',
-        loader: {
-            '.js': 'jsx',
-            '.ts': 'ts',
-            '.css': 'css', // Add CSS loader
-        },
-        sourcemap: 'inline',
-        external: ['server-only'],
-        define: {
-            React: 'global.React',
-        },
-        plugins: [],
-    };
-    // Add the custom plugin to handle 'server-only' imports
-    esbuildOptions.plugins?.push({
-        name: 'ignore-server-only',
-        setup(build) {
-            build.onResolve({ filter: /^server-only$/ }, () => {
-                return {
-                    path: 'server-only',
-                    namespace: 'ignore-server-only',
-                };
-            });
-            build.onLoad({ filter: /^server-only$/, namespace: 'ignore-server-only' }, () => {
-                return {
-                    contents: 'module.exports = {};',
-                    loader: 'js',
-                };
-            });
-        },
-    });
-    // Add a plugin to handle CSS imports
-    esbuildOptions.plugins?.push({
-        name: 'css-module',
-        setup(build) {
-            build.onResolve({ filter: /\.css$/ }, (args) => {
-                return {
-                    path: path.resolve(args.resolveDir, args.path),
-                    namespace: 'css-module',
-                };
-            });
-            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, async (args) => {
-                const css = await fs.promises.readFile(args.path, 'utf8');
-                const contents = `
+import { displayResolvedPaths } from "../../console/logging.js";
+import path from "node:path";
+import fs from "node:fs";
+//#region src/react/config/createESBuildConfig.ts
+function createESBuildConfig(config = {}) {
+	const esbuildOptions = {
+		bundle: true,
+		format: "cjs",
+		platform: "node",
+		target: "es2021",
+		loader: {
+			".js": "jsx",
+			".ts": "ts",
+			".css": "css"
+		},
+		sourcemap: "inline",
+		external: ["server-only"],
+		define: { React: "global.React" },
+		plugins: []
+	};
+	esbuildOptions.plugins?.push({
+		name: "ignore-server-only",
+		setup(build) {
+			build.onResolve({ filter: /^server-only$/ }, () => {
+				return {
+					path: "server-only",
+					namespace: "ignore-server-only"
+				};
+			});
+			build.onLoad({
+				filter: /^server-only$/,
+				namespace: "ignore-server-only"
+			}, () => {
+				return {
+					contents: "module.exports = {};",
+					loader: "js"
+				};
+			});
+		}
+	});
+	esbuildOptions.plugins?.push({
+		name: "css-module",
+		setup(build) {
+			build.onResolve({ filter: /\.css$/ }, (args) => {
+				return {
+					path: path.resolve(args.resolveDir, args.path),
+					namespace: "css-module"
+				};
+			});
+			build.onLoad({
+				filter: /\.css$/,
+				namespace: "css-module"
+			}, async (args) => {
+				const css = await fs.promises.readFile(args.path, "utf8");
+				return {
+					contents: `
                     const style = document.createElement('style');
                     style.textContent = ${JSON.stringify(css)};
                     document.head.appendChild(style);
-                `;
-                return { contents, loader: 'js' };
-            });
-        },
-    });
-    if (config.compilerOptions) {
-        if (config.compilerOptions.paths) {
-            const aliases = {};
-            const resolvedPaths = [];
-            for (const [key, value] of Object.entries(config.compilerOptions.paths)) {
-                if (Array.isArray(value) && typeof value[0] === 'string') {
-                    const resolvedPath = path.resolve(process.cwd(), value[0].replace('/*', ''));
-                    aliases[key.replace('/*', '')] = resolvedPath;
-                    resolvedPaths.push([key, resolvedPath]);
-                }
-            }
-            if (resolvedPaths.length) {
-                displayResolvedPaths(resolvedPaths);
-            }
-            esbuildOptions.plugins = esbuildOptions.plugins || [];
-            esbuildOptions.plugins.push({
-                name: 'alias',
-                setup(build) {
-                    build.onResolve({ filter: /.*/ }, (args) => {
-                        for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
-                            if (args.path.startsWith(`${aliasKey}/`)) {
-                                const resolvedPath = path.resolve(aliasPath, args.path.slice(aliasKey.length + 1));
-                                const extensions = ['.js', '.ts', '.css']; // Add .css to extensions
-                                function resolveWithExtensions(basePath) {
-                                    for (const ext of extensions) {
-                                        const fullPath = `${basePath}${ext}`;
-                                        try {
-                                            const realPath = fs.realpathSync(fullPath);
-                                            return realPath;
-                                        }
-                                        catch {
-                                            continue;
-                                        }
-                                    }
-                                    return null;
-                                }
-                                try {
-                                    const realPath = fs.realpathSync(resolvedPath);
-                                    return { path: realPath };
-                                }
-                                catch {
-                                    const hasExtension = extensions.some((ext) => resolvedPath.endsWith(ext));
-                                    if (!hasExtension) {
-                                        const resolvedWithExt = resolveWithExtensions(resolvedPath);
-                                        if (resolvedWithExt) {
-                                            return { path: resolvedWithExt };
-                                        }
-                                    }
-                                    throw new Error(`Unable to resolve path: ${resolvedPath}`);
-                                }
-                            }
-                        }
-                    });
-                },
-            });
-        }
-    }
-    return esbuildOptions;
+                `,
+					loader: "js"
+				};
+			});
+		}
+	});
+	if (config.compilerOptions) {
+		if (config.compilerOptions.paths) {
+			const aliases = {};
+			const resolvedPaths = [];
+			for (const [key, value] of Object.entries(config.compilerOptions.paths)) if (Array.isArray(value) && typeof value[0] === "string") {
+				const resolvedPath = path.resolve(process.cwd(), value[0].replace("/*", ""));
+				aliases[key.replace("/*", "")] = resolvedPath;
+				resolvedPaths.push([key, resolvedPath]);
+			}
+			if (resolvedPaths.length) displayResolvedPaths(resolvedPaths);
+			esbuildOptions.plugins = esbuildOptions.plugins || [];
+			esbuildOptions.plugins.push({
+				name: "alias",
+				setup(build) {
+					build.onResolve({ filter: /.*/ }, (args) => {
+						for (const [aliasKey, aliasPath] of Object.entries(aliases)) if (args.path.startsWith(`${aliasKey}/`)) {
+							const resolvedPath = path.resolve(aliasPath, args.path.slice(aliasKey.length + 1));
+							const extensions = [
+								".js",
+								".ts",
+								".css"
+							];
+							function resolveWithExtensions(basePath) {
+								for (const ext of extensions) {
+									const fullPath = `${basePath}${ext}`;
+									try {
+										return fs.realpathSync(fullPath);
+									} catch {
+										continue;
+									}
+								}
+								return null;
+							}
+							try {
+								return { path: fs.realpathSync(resolvedPath) };
+							} catch {
+								if (!extensions.some((ext) => resolvedPath.endsWith(ext))) {
+									const resolvedWithExt = resolveWithExtensions(resolvedPath);
+									if (resolvedWithExt) return { path: resolvedWithExt };
+								}
+								throw new Error(`Unable to resolve path: ${resolvedPath}`);
+							}
+						}
+					});
+				}
+			});
+		}
+	}
+	return esbuildOptions;
 }
+//#endregion
+export { createESBuildConfig as default };
+
+//# sourceMappingURL=createESBuildConfig.js.map

package/dist/react/config/createESBuildConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createESBuildConfig.js","names":[],"sources":["../../../src/react/config/createESBuildConfig.ts"],"sourcesContent":["import esbuild from 'esbuild';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { displayResolvedPaths } from '../../console/logging.js';\n\ntype TSConfig = {\n  compilerOptions?: {\n    paths?: Record<string, string[]>;\n  };\n};\n\nexport default function createESBuildConfig(config: TSConfig = {}) {\n  const esbuildOptions: esbuild.BuildOptions = {\n    bundle: true,\n    format: 'cjs',\n    platform: 'node',\n    target: 'es2021',\n    loader: {\n      '.js': 'jsx',\n      '.ts': 'ts',\n      '.css': 'css', // Add CSS loader\n    },\n    sourcemap: 'inline',\n    external: ['server-only'],\n    define: {\n      React: 'global.React',\n    },\n    plugins: [],\n  };\n\n  // Add the custom plugin to handle 'server-only' imports\n  esbuildOptions.plugins?.push({\n    name: 'ignore-server-only',\n    setup(build: esbuild.PluginBuild) {\n      build.onResolve({ filter: /^server-only$/ }, () => {\n        return {\n          path: 'server-only',\n          namespace: 'ignore-server-only',\n        };\n      });\n\n      build.onLoad(\n        { filter: /^server-only$/, namespace: 'ignore-server-only' },\n        () => {\n          return {\n            contents: 'module.exports = {};',\n            loader: 'js',\n          };\n        }\n      );\n    },\n  });\n\n  // Add a plugin to handle CSS imports\n  esbuildOptions.plugins?.push({\n    name: 'css-module',\n    setup(build: esbuild.PluginBuild) {\n      build.onResolve({ filter: /\\.css$/ }, (args: esbuild.OnResolveArgs) => {\n        return {\n          path: path.resolve(args.resolveDir, args.path),\n          namespace: 'css-module',\n        };\n      });\n\n      build.onLoad(\n        { filter: /\\.css$/, namespace: 'css-module' },\n        async (args: esbuild.OnLoadArgs) => {\n          const css = await fs.promises.readFile(args.path, 'utf8');\n          const contents = `\n                    const style = document.createElement('style');\n                    style.textContent = ${JSON.stringify(css)};\n                    document.head.appendChild(style);\n                `;\n          return { contents, loader: 'js' };\n        }\n      );\n    },\n  });\n\n  if (config.compilerOptions) {\n    if (config.compilerOptions.paths) {\n      const aliases: Record<string, string> = {};\n\n      const resolvedPaths: [string, string][] = [];\n      for (const [key, value] of Object.entries(config.compilerOptions.paths)) {\n        if (Array.isArray(value) && typeof value[0] === 'string') {\n          const resolvedPath = path.resolve(\n            process.cwd(),\n            value[0].replace('/*', '')\n          );\n          aliases[key.replace('/*', '')] = resolvedPath;\n          resolvedPaths.push([key, resolvedPath]);\n        }\n      }\n      if (resolvedPaths.length) {\n        displayResolvedPaths(resolvedPaths);\n      }\n\n      esbuildOptions.plugins = esbuildOptions.plugins || [];\n\n      esbuildOptions.plugins.push({\n        name: 'alias',\n        setup(build) {\n          build.onResolve({ filter: /.*/ }, (args) => {\n            for (const [aliasKey, aliasPath] of Object.entries(aliases)) {\n              if (args.path.startsWith(`${aliasKey}/`)) {\n                const resolvedPath = path.resolve(\n                  aliasPath as string,\n                  args.path.slice(aliasKey.length + 1)\n                );\n\n                const extensions = ['.js', '.ts', '.css']; // Add .css to extensions\n\n                function resolveWithExtensions(\n                  basePath: string\n                ): string | null {\n                  for (const ext of extensions) {\n                    const fullPath = `${basePath}${ext}`;\n                    try {\n                      const realPath = fs.realpathSync(fullPath);\n                      return realPath;\n                    } catch {\n                      continue;\n                    }\n                  }\n                  return null;\n                }\n\n                try {\n                  const realPath = fs.realpathSync(resolvedPath);\n                  return { path: realPath };\n                } catch {\n                  const hasExtension = extensions.some((ext) =>\n                    resolvedPath.endsWith(ext)\n                  );\n                  if (!hasExtension) {\n                    const resolvedWithExt = resolveWithExtensions(resolvedPath);\n                    if (resolvedWithExt) {\n                      return { path: resolvedWithExt };\n                    }\n                  }\n\n                  throw new Error(`Unable to resolve path: ${resolvedPath}`);\n                }\n              }\n            }\n          });\n        },\n      });\n    }\n  }\n\n  return esbuildOptions;\n}\n"],"mappings":";;;;AAWA,SAAwB,oBAAoB,SAAmB,EAAE,EAAE;CACjE,MAAM,iBAAuC;EAC3C,QAAQ;EACR,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,QAAQ;GACN,OAAO;GACP,OAAO;GACP,QAAQ;GACT;EACD,WAAW;EACX,UAAU,CAAC,cAAc;EACzB,QAAQ,EACN,OAAO,gBACR;EACD,SAAS,EAAE;EACZ;AAGD,gBAAe,SAAS,KAAK;EAC3B,MAAM;EACN,MAAM,OAA4B;AAChC,SAAM,UAAU,EAAE,QAAQ,iBAAiB,QAAQ;AACjD,WAAO;KACL,MAAM;KACN,WAAW;KACZ;KACD;AAEF,SAAM,OACJ;IAAE,QAAQ;IAAiB,WAAW;IAAsB,QACtD;AACJ,WAAO;KACL,UAAU;KACV,QAAQ;KACT;KAEJ;;EAEJ,CAAC;AAGF,gBAAe,SAAS,KAAK;EAC3B,MAAM;EACN,MAAM,OAA4B;AAChC,SAAM,UAAU,EAAE,QAAQ,UAAU,GAAG,SAAgC;AACrE,WAAO;KACL,MAAM,KAAK,QAAQ,KAAK,YAAY,KAAK,KAAK;KAC9C,WAAW;KACZ;KACD;AAEF,SAAM,OACJ;IAAE,QAAQ;IAAU,WAAW;IAAc,EAC7C,OAAO,SAA6B;IAClC,MAAM,MAAM,MAAM,GAAG,SAAS,SAAS,KAAK,MAAM,OAAO;AAMzD,WAAO;KAAE,UAAA;;0CAHuB,KAAK,UAAU,IAAI,CAAC;;;KAGjC,QAAQ;KAAM;KAEpC;;EAEJ,CAAC;AAEF,KAAI,OAAO;MACL,OAAO,gBAAgB,OAAO;GAChC,MAAM,UAAkC,EAAE;GAE1C,MAAM,gBAAoC,EAAE;AAC5C,QAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,gBAAgB,MAAM,CACrE,KAAI,MAAM,QAAQ,MAAM,IAAI,OAAO,MAAM,OAAO,UAAU;IACxD,MAAM,eAAe,KAAK,QACxB,QAAQ,KAAK,EACb,MAAM,GAAG,QAAQ,MAAM,GAAG,CAC3B;AACD,YAAQ,IAAI,QAAQ,MAAM,GAAG,IAAI;AACjC,kBAAc,KAAK,CAAC,KAAK,aAAa,CAAC;;AAG3C,OAAI,cAAc,OAChB,sBAAqB,cAAc;AAGrC,kBAAe,UAAU,eAAe,WAAW,EAAE;AAErD,kBAAe,QAAQ,KAAK;IAC1B,MAAM;IACN,MAAM,OAAO;AACX,WAAM,UAAU,EAAE,QAAQ,MAAM,GAAG,SAAS;AAC1C,WAAK,MAAM,CAAC,UAAU,cAAc,OAAO,QAAQ,QAAQ,CACzD,KAAI,KAAK,KAAK,WAAW,GAAG,SAAS,GAAG,EAAE;OACxC,MAAM,eAAe,KAAK,QACxB,WACA,KAAK,KAAK,MAAM,SAAS,SAAS,EAAE,CACrC;OAED,MAAM,aAAa;QAAC;QAAO;QAAO;QAAO;OAEzC,SAAS,sBACP,UACe;AACf,aAAK,MAAM,OAAO,YAAY;SAC5B,MAAM,WAAW,GAAG,WAAW;AAC/B,aAAI;AAEF,iBADiB,GAAG,aAAa,SAClB;iBACT;AACN;;;AAGJ,eAAO;;AAGT,WAAI;AAEF,eAAO,EAAE,MADQ,GAAG,aAAa,aACV,EAAE;eACnB;AAIN,YAAI,CAHiB,WAAW,MAAM,QACpC,aAAa,SAAS,IAAI,CAEX,EAAE;SACjB,MAAM,kBAAkB,sBAAsB,aAAa;AAC3D,aAAI,gBACF,QAAO,EAAE,MAAM,iBAAiB;;AAIpC,cAAM,IAAI,MAAM,2BAA2B,eAAe;;;OAIhE;;IAEL,CAAC;;;AAIN,QAAO"}

package/dist/react/jsx/evaluateJsx.js

@@ -1,133 +1,99 @@
-import * as t from '@babel/types';
-import { parse } from '@formatjs/icu-messageformat-parser';
+import * as t from "@babel/types";
+import { parse } from "@formatjs/icu-messageformat-parser";
+//#region src/react/jsx/evaluateJsx.ts
 const MEANINGFUL_REGEX = /[\p{L}\p{N}]/u;
 /**
- * Checks if a node is meaningful. Does not recurse into children.
- * @param node - The node to check
- * @returns Whether the node is meaningful
- */
-export function isMeaningful(node) {
-    if (t.isStringLiteral(node) || t.isJSXText(node)) {
-        return MEANINGFUL_REGEX.test(node.value);
-    }
-    // Handle template literals without expressions
-    if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
-        return MEANINGFUL_REGEX.test(node.quasis[0].value.raw);
-    }
-    if (t.isJSXExpressionContainer(node)) {
-        const value = isStaticExpression(node.expression);
-        if (value.isStatic && value.value) {
-            return MEANINGFUL_REGEX.test(value.value);
-        }
-    }
-    if (t.isBinaryExpression(node)) {
-        if (node.operator === '+') {
-            return isMeaningful(node.left) || isMeaningful(node.right);
-        }
-    }
-    return false;
+* Checks if a node is meaningful. Does not recurse into children.
+* @param node - The node to check
+* @returns Whether the node is meaningful
+*/
+function isMeaningful(node) {
+	if (t.isStringLiteral(node) || t.isJSXText(node)) return MEANINGFUL_REGEX.test(node.value);
+	if (t.isTemplateLiteral(node) && node.expressions.length === 0) return MEANINGFUL_REGEX.test(node.quasis[0].value.raw);
+	if (t.isJSXExpressionContainer(node)) {
+		const value = isStaticExpression(node.expression);
+		if (value.isStatic && value.value) return MEANINGFUL_REGEX.test(value.value);
+	}
+	if (t.isBinaryExpression(node)) {
+		if (node.operator === "+") return isMeaningful(node.left) || isMeaningful(node.right);
+	}
+	return false;
 }
 /**
- * Checks if an expression is a static expression (does not contain any variables which could change at runtime).
- * @param expr - The expression to check
- * @param jsxStatic - Whether to return JSX-compatible values (boolean, null) in addition to strings
- * @returns An object containing the result of the static check
- */
-export function isStaticExpression(expr, jsxStatic = false) {
-    // Handle empty expressions
-    if (t.isJSXEmptyExpression(expr)) {
-        return { isStatic: true, value: '' };
-    }
-    // Handle direct string literals
-    if (t.isStringLiteral(expr)) {
-        return { isStatic: true, value: expr.value };
-    }
-    // Handle template literals without expressions
-    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
-        return {
-            isStatic: true,
-            value: jsxStatic ? expr.quasis[0].value.cooked : expr.quasis[0].value.raw,
-        };
-    }
-    // Binary expressions are not derivable
-    if (t.isBinaryExpression(expr)) {
-        // Not a derivable expression
-        return { isStatic: false };
-    }
-    // Handle parenthesized expressions
-    if (t.isParenthesizedExpression(expr)) {
-        return isStaticExpression(expr.expression, jsxStatic);
-    }
-    // Handle numeric literals by converting them to strings
-    if (t.isNumericLiteral(expr)) {
-        return { isStatic: true, value: String(expr.value) };
-    }
-    // Handle unary expressions by converting them to strings
-    if (t.isUnaryExpression(expr)) {
-        let value;
-        let operator = '';
-        if (expr.operator === '-') {
-            operator = expr.operator;
-        }
-        if (t.isNumericLiteral(expr.argument)) {
-            if (expr.argument.value === 0) {
-                value = '0';
-            }
-            else {
-                value = operator + expr.argument.value.toString();
-            }
-        }
-        else {
-            // invalid
-            return { isStatic: false };
-        }
-        return { isStatic: true, value };
-    }
-    // Handle boolean literals by converting them to strings
-    if (t.isBooleanLiteral(expr)) {
-        return {
-            isStatic: true,
-            value: jsxStatic ? expr.value : String(expr.value),
-        };
-    }
-    // Handle null literal
-    if (t.isNullLiteral(expr)) {
-        return { isStatic: true, value: jsxStatic ? null : 'null' };
-    }
-    // Not a derivable expression
-    return { isStatic: false };
+* Checks if an expression is a static expression (does not contain any variables which could change at runtime).
+* @param expr - The expression to check
+* @param jsxStatic - Whether to return JSX-compatible values (boolean, null) in addition to strings
+* @returns An object containing the result of the static check
+*/
+function isStaticExpression(expr, jsxStatic = false) {
+	if (t.isJSXEmptyExpression(expr)) return {
+		isStatic: true,
+		value: ""
+	};
+	if (t.isStringLiteral(expr)) return {
+		isStatic: true,
+		value: expr.value
+	};
+	if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) return {
+		isStatic: true,
+		value: jsxStatic ? expr.quasis[0].value.cooked : expr.quasis[0].value.raw
+	};
+	if (t.isBinaryExpression(expr)) return { isStatic: false };
+	if (t.isParenthesizedExpression(expr)) return isStaticExpression(expr.expression, jsxStatic);
+	if (t.isNumericLiteral(expr)) return {
+		isStatic: true,
+		value: String(expr.value)
+	};
+	if (t.isUnaryExpression(expr)) {
+		let value;
+		let operator = "";
+		if (expr.operator === "-") operator = expr.operator;
+		if (t.isNumericLiteral(expr.argument)) if (expr.argument.value === 0) value = "0";
+		else value = operator + expr.argument.value.toString();
+		else return { isStatic: false };
+		return {
+			isStatic: true,
+			value
+		};
+	}
+	if (t.isBooleanLiteral(expr)) return {
+		isStatic: true,
+		value: jsxStatic ? expr.value : String(expr.value)
+	};
+	if (t.isNullLiteral(expr)) return {
+		isStatic: true,
+		value: jsxStatic ? null : "null"
+	};
+	return { isStatic: false };
 }
 /**
- * Checks if an expression is a static value (a string, number, or template literal).
- * @param expr - The expression to check
- * @returns Whether the expression is a static value
- */
-export function isStaticValue(expr) {
-    if (t.isStringLiteral(expr)) {
-        return true;
-    }
-    if (t.isNumericLiteral(expr)) {
-        return true;
-    }
-    if (t.isTemplateLiteral(expr)) {
-        return true;
-    }
-    return false;
+* Checks if an expression is a static value (a string, number, or template literal).
+* @param expr - The expression to check
+* @returns Whether the expression is a static value
+*/
+function isStaticValue(expr) {
+	if (t.isStringLiteral(expr)) return true;
+	if (t.isNumericLiteral(expr)) return true;
+	if (t.isTemplateLiteral(expr)) return true;
+	return false;
 }
 /**
- * Checks if a string is a valid ICU message format.
- * @param string - The string to check
- * @returns Whether the string is a valid ICU message format
- */
-export function isValidIcu(string) {
-    try {
-        parse(string);
-    }
-    catch (error) {
-        return {
-            isValid: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-    return { isValid: true };
+* Checks if a string is a valid ICU message format.
+* @param string - The string to check
+* @returns Whether the string is a valid ICU message format
+*/
+function isValidIcu(string) {
+	try {
+		parse(string);
+	} catch (error) {
+		return {
+			isValid: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	return { isValid: true };
 }
+//#endregion
+export { isMeaningful, isStaticExpression, isStaticValue, isValidIcu };
+
+//# sourceMappingURL=evaluateJsx.js.map

package/dist/react/jsx/evaluateJsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateJsx.js","names":[],"sources":["../../../src/react/jsx/evaluateJsx.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { parse } from '@formatjs/icu-messageformat-parser';\n\nconst MEANINGFUL_REGEX = /[\\p{L}\\p{N}]/u;\n\n/**\n * Checks if a node is meaningful. Does not recurse into children.\n * @param node - The node to check\n * @returns Whether the node is meaningful\n */\nexport function isMeaningful(node: t.Node): boolean {\n  if (t.isStringLiteral(node) || t.isJSXText(node)) {\n    return MEANINGFUL_REGEX.test(node.value);\n  }\n  // Handle template literals without expressions\n  if (t.isTemplateLiteral(node) && node.expressions.length === 0) {\n    return MEANINGFUL_REGEX.test(node.quasis[0].value.raw);\n  }\n  if (t.isJSXExpressionContainer(node)) {\n    const value = isStaticExpression(node.expression);\n    if (value.isStatic && value.value) {\n      return MEANINGFUL_REGEX.test(value.value);\n    }\n  }\n  if (t.isBinaryExpression(node)) {\n    if (node.operator === '+') {\n      return isMeaningful(node.left) || isMeaningful(node.right);\n    }\n  }\n  return false;\n}\n\nexport function isStaticExpression(\n  expr: t.Expression | t.JSXEmptyExpression,\n  jsxStatic?: false\n): {\n  isStatic: boolean;\n  value?: string;\n};\nexport function isStaticExpression(\n  expr: t.Expression | t.JSXEmptyExpression,\n  jsxStatic?: true\n): {\n  isStatic: boolean;\n  value?: string | boolean | null;\n};\nexport function isStaticExpression(\n  expr: t.Expression | t.JSXEmptyExpression,\n  jsxStatic?: boolean\n): {\n  isStatic: boolean;\n  value?: string | boolean | null;\n};\n/**\n * Checks if an expression is a static expression (does not contain any variables which could change at runtime).\n * @param expr - The expression to check\n * @param jsxStatic - Whether to return JSX-compatible values (boolean, null) in addition to strings\n * @returns An object containing the result of the static check\n */\nexport function isStaticExpression(\n  expr: t.Expression | t.JSXEmptyExpression,\n  jsxStatic = false\n): {\n  isStatic: boolean;\n  value?: string | boolean | null;\n} {\n  // Handle empty expressions\n  if (t.isJSXEmptyExpression(expr)) {\n    return { isStatic: true, value: '' };\n  }\n\n  // Handle direct string literals\n  if (t.isStringLiteral(expr)) {\n    return { isStatic: true, value: expr.value };\n  }\n\n  // Handle template literals without expressions\n  if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {\n    return {\n      isStatic: true,\n      value: jsxStatic ? expr.quasis[0].value.cooked : expr.quasis[0].value.raw,\n    };\n  }\n\n  // Binary expressions are not derivable\n  if (t.isBinaryExpression(expr)) {\n    // Not a derivable expression\n    return { isStatic: false };\n  }\n\n  // Handle parenthesized expressions\n  if (t.isParenthesizedExpression(expr)) {\n    return isStaticExpression(expr.expression, jsxStatic);\n  }\n\n  // Handle numeric literals by converting them to strings\n  if (t.isNumericLiteral(expr)) {\n    return { isStatic: true, value: String(expr.value) };\n  }\n\n  // Handle unary expressions by converting them to strings\n  if (t.isUnaryExpression(expr)) {\n    let value: string;\n    let operator = '';\n    if (expr.operator === '-') {\n      operator = expr.operator;\n    }\n    if (t.isNumericLiteral(expr.argument)) {\n      if (expr.argument.value === 0) {\n        value = '0';\n      } else {\n        value = operator + expr.argument.value.toString();\n      }\n    } else {\n      // invalid\n      return { isStatic: false };\n    }\n\n    return { isStatic: true, value };\n  }\n\n  // Handle boolean literals by converting them to strings\n  if (t.isBooleanLiteral(expr)) {\n    return {\n      isStatic: true,\n      value: jsxStatic ? expr.value : String(expr.value),\n    };\n  }\n\n  // Handle null literal\n  if (t.isNullLiteral(expr)) {\n    return { isStatic: true, value: jsxStatic ? null : 'null' };\n  }\n\n  // Not a derivable expression\n  return { isStatic: false };\n}\n\n/**\n * Checks if an expression is a static value (a string, number, or template literal).\n * @param expr - The expression to check\n * @returns Whether the expression is a static value\n */\nexport function isStaticValue(\n  expr: t.Expression | t.JSXEmptyExpression\n): boolean {\n  if (t.isStringLiteral(expr)) {\n    return true;\n  }\n  if (t.isNumericLiteral(expr)) {\n    return true;\n  }\n  if (t.isTemplateLiteral(expr)) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Checks if a string is a valid ICU message format.\n * @param string - The string to check\n * @returns Whether the string is a valid ICU message format\n */\nexport function isValidIcu(string: string): {\n  isValid: boolean;\n  error?: string;\n} {\n  try {\n    parse(string);\n  } catch (error) {\n    return {\n      isValid: false,\n      error: error instanceof Error ? error.message : String(error),\n    };\n  }\n  return { isValid: true };\n}\n"],"mappings":";;;AAGA,MAAM,mBAAmB;;;;;;AAOzB,SAAgB,aAAa,MAAuB;AAClD,KAAI,EAAE,gBAAgB,KAAK,IAAI,EAAE,UAAU,KAAK,CAC9C,QAAO,iBAAiB,KAAK,KAAK,MAAM;AAG1C,KAAI,EAAE,kBAAkB,KAAK,IAAI,KAAK,YAAY,WAAW,EAC3D,QAAO,iBAAiB,KAAK,KAAK,OAAO,GAAG,MAAM,IAAI;AAExD,KAAI,EAAE,yBAAyB,KAAK,EAAE;EACpC,MAAM,QAAQ,mBAAmB,KAAK,WAAW;AACjD,MAAI,MAAM,YAAY,MAAM,MAC1B,QAAO,iBAAiB,KAAK,MAAM,MAAM;;AAG7C,KAAI,EAAE,mBAAmB,KAAK;MACxB,KAAK,aAAa,IACpB,QAAO,aAAa,KAAK,KAAK,IAAI,aAAa,KAAK,MAAM;;AAG9D,QAAO;;;;;;;;AA8BT,SAAgB,mBACd,MACA,YAAY,OAIZ;AAEA,KAAI,EAAE,qBAAqB,KAAK,CAC9B,QAAO;EAAE,UAAU;EAAM,OAAO;EAAI;AAItC,KAAI,EAAE,gBAAgB,KAAK,CACzB,QAAO;EAAE,UAAU;EAAM,OAAO,KAAK;EAAO;AAI9C,KAAI,EAAE,kBAAkB,KAAK,IAAI,KAAK,YAAY,WAAW,EAC3D,QAAO;EACL,UAAU;EACV,OAAO,YAAY,KAAK,OAAO,GAAG,MAAM,SAAS,KAAK,OAAO,GAAG,MAAM;EACvE;AAIH,KAAI,EAAE,mBAAmB,KAAK,CAE5B,QAAO,EAAE,UAAU,OAAO;AAI5B,KAAI,EAAE,0BAA0B,KAAK,CACnC,QAAO,mBAAmB,KAAK,YAAY,UAAU;AAIvD,KAAI,EAAE,iBAAiB,KAAK,CAC1B,QAAO;EAAE,UAAU;EAAM,OAAO,OAAO,KAAK,MAAM;EAAE;AAItD,KAAI,EAAE,kBAAkB,KAAK,EAAE;EAC7B,IAAI;EACJ,IAAI,WAAW;AACf,MAAI,KAAK,aAAa,IACpB,YAAW,KAAK;AAElB,MAAI,EAAE,iBAAiB,KAAK,SAAS,CACnC,KAAI,KAAK,SAAS,UAAU,EAC1B,SAAQ;MAER,SAAQ,WAAW,KAAK,SAAS,MAAM,UAAU;MAInD,QAAO,EAAE,UAAU,OAAO;AAG5B,SAAO;GAAE,UAAU;GAAM;GAAO;;AAIlC,KAAI,EAAE,iBAAiB,KAAK,CAC1B,QAAO;EACL,UAAU;EACV,OAAO,YAAY,KAAK,QAAQ,OAAO,KAAK,MAAM;EACnD;AAIH,KAAI,EAAE,cAAc,KAAK,CACvB,QAAO;EAAE,UAAU;EAAM,OAAO,YAAY,OAAO;EAAQ;AAI7D,QAAO,EAAE,UAAU,OAAO;;;;;;;AAQ5B,SAAgB,cACd,MACS;AACT,KAAI,EAAE,gBAAgB,KAAK,CACzB,QAAO;AAET,KAAI,EAAE,iBAAiB,KAAK,CAC1B,QAAO;AAET,KAAI,EAAE,kBAAkB,KAAK,CAC3B,QAAO;AAET,QAAO;;;;;;;AAQT,SAAgB,WAAW,QAGzB;AACA,KAAI;AACF,QAAM,OAAO;UACN,OAAO;AACd,SAAO;GACL,SAAS;GACT,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC9D;;AAEH,QAAO,EAAE,SAAS,MAAM"}

package/dist/react/jsx/utils/buildImportMap.js

@@ -1,30 +1,26 @@
-import * as t from '@babel/types';
+import * as t from "@babel/types";
+//#region src/react/jsx/utils/buildImportMap.ts
 /**
- * Builds a map of imported function names to their import paths from a given program path.
- * Handles both named imports and default imports.
- *
- * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
- * Example: import utils from './utils' -> Map { 'utils' => './utils' }
- */
-export function buildImportMap(programPath) {
-    const importMap = new Map();
-    programPath.traverse({
-        ImportDeclaration(importPath) {
-            if (t.isStringLiteral(importPath.node.source)) {
-                const importSource = importPath.node.source.value;
-                importPath.node.specifiers.forEach((spec) => {
-                    if (t.isImportSpecifier(spec) &&
-                        t.isIdentifier(spec.imported) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                    else if (t.isImportDefaultSpecifier(spec) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                });
-            }
-        },
-    });
-    return importMap;
+* Builds a map of imported function names to their import paths from a given program path.
+* Handles both named imports and default imports.
+*
+* Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
+* Example: import utils from './utils' -> Map { 'utils' => './utils' }
+*/
+function buildImportMap(programPath) {
+	const importMap = /* @__PURE__ */ new Map();
+	programPath.traverse({ ImportDeclaration(importPath) {
+		if (t.isStringLiteral(importPath.node.source)) {
+			const importSource = importPath.node.source.value;
+			importPath.node.specifiers.forEach((spec) => {
+				if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported) && t.isIdentifier(spec.local)) importMap.set(spec.local.name, importSource);
+				else if (t.isImportDefaultSpecifier(spec) && t.isIdentifier(spec.local)) importMap.set(spec.local.name, importSource);
+			});
+		}
+	} });
+	return importMap;
 }
+//#endregion
+export { buildImportMap };
+
+//# sourceMappingURL=buildImportMap.js.map

package/dist/react/jsx/utils/buildImportMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildImportMap.js","names":[],"sources":["../../../../src/react/jsx/utils/buildImportMap.ts"],"sourcesContent":["import { NodePath } from '@babel/traverse';\nimport * as t from '@babel/types';\n\n/**\n * Builds a map of imported function names to their import paths from a given program path.\n * Handles both named imports and default imports.\n *\n * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }\n * Example: import utils from './utils' -> Map { 'utils' => './utils' }\n */\nexport function buildImportMap(programPath: NodePath): Map<string, string> {\n  const importMap = new Map<string, string>();\n\n  programPath.traverse({\n    ImportDeclaration(importPath) {\n      if (t.isStringLiteral(importPath.node.source)) {\n        const importSource = importPath.node.source.value;\n        importPath.node.specifiers.forEach((spec) => {\n          if (\n            t.isImportSpecifier(spec) &&\n            t.isIdentifier(spec.imported) &&\n            t.isIdentifier(spec.local)\n          ) {\n            importMap.set(spec.local.name, importSource);\n          } else if (\n            t.isImportDefaultSpecifier(spec) &&\n            t.isIdentifier(spec.local)\n          ) {\n            importMap.set(spec.local.name, importSource);\n          }\n        });\n      }\n    },\n  });\n\n  return importMap;\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,eAAe,aAA4C;CACzE,MAAM,4BAAY,IAAI,KAAqB;AAE3C,aAAY,SAAS,EACnB,kBAAkB,YAAY;AAC5B,MAAI,EAAE,gBAAgB,WAAW,KAAK,OAAO,EAAE;GAC7C,MAAM,eAAe,WAAW,KAAK,OAAO;AAC5C,cAAW,KAAK,WAAW,SAAS,SAAS;AAC3C,QACE,EAAE,kBAAkB,KAAK,IACzB,EAAE,aAAa,KAAK,SAAS,IAC7B,EAAE,aAAa,KAAK,MAAM,CAE1B,WAAU,IAAI,KAAK,MAAM,MAAM,aAAa;aAE5C,EAAE,yBAAyB,KAAK,IAChC,EAAE,aAAa,KAAK,MAAM,CAE1B,WAAU,IAAI,KAAK,MAAM,MAAM,aAAa;KAE9C;;IAGP,CAAC;AAEF,QAAO"}