@equinor/fusion-imports 1.1.8 → 1.2.0-next.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-imports",
-  "version": "1.1.8",
+  "version": "1.2.0-next.0",
   "description": "Package import files and configurations",
   "keywords": [
     "esbuild",

package/src/import-meta-resolve-plugin.ts

@@ -0,0 +1,171 @@
+import type { BuildResult, Plugin } from 'esbuild';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * Transforms import.meta.resolve() calls in code to resolved file:// URLs
+ * @param code - The code to transform
+ * @param baseDir - The base directory for resolving relative paths
+ * @returns The transformed code
+ */
+function transformImportMetaResolve(code: string, baseDir: string): string {
+  return code.replace(
+    /import\.meta\.resolve\((['"`])([^'"`]+)\1\)/g,
+    (match: string, quote: string, specifier: string) => {
+      try {
+        // Only resolve relative paths (./ or ../), skip package imports
+        if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
+          return match;
+        }
+
+        const resolvedPath = path.resolve(baseDir, specifier);
+        const fileUrl = pathToFileURL(resolvedPath).href;
+        return `${quote}${fileUrl}${quote}`;
+      } catch {
+        // If resolution fails, leave it as-is
+        return match;
+      }
+    },
+  );
+}
+
+/**
+ * Gets the appropriate esbuild loader for a file extension
+ */
+function getLoader(filePath: string): 'ts' | 'tsx' | 'js' | 'jsx' | undefined {
+  const ext = path.extname(filePath);
+  if (ext === '.tsx' || ext === '.jsx') {
+    return ext === '.tsx' ? 'tsx' : 'jsx';
+  }
+  if (ext === '.ts' || ext === '.mts') {
+    return 'ts';
+  }
+  if (ext === '.js' || ext === '.mjs') {
+    return 'js';
+  }
+  return undefined;
+}
+
+/**
+ * Safely reads a file, returning undefined on error
+ */
+async function readFileSafe(filePath: string): Promise<string | undefined> {
+  try {
+    const fs = await import('node:fs/promises');
+    return await fs.readFile(filePath, 'utf-8');
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Collects output files from esbuild result (handles both write: true and write: false)
+ */
+async function collectOutputFiles(
+  result: BuildResult,
+): Promise<Array<{ path: string; text: string }>> {
+  const files: Array<{ path: string; text: string }> = [];
+  const processedPaths = new Set<string>();
+
+  // Collect from outputFiles (write: false case - files in memory)
+  if (result.outputFiles) {
+    for (const outputFile of result.outputFiles) {
+      if (outputFile.path.endsWith('.js') || outputFile.path.endsWith('.mjs')) {
+        files.push({ path: outputFile.path, text: outputFile.text });
+        processedPaths.add(outputFile.path);
+      }
+    }
+  }
+
+  // Collect from metafile (write: true case - files on disk)
+  if (result.metafile?.outputs) {
+    for (const outputPath of Object.keys(result.metafile.outputs)) {
+      if (processedPaths.has(outputPath)) {
+        continue;
+      }
+
+      if (outputPath.endsWith('.js') || outputPath.endsWith('.mjs')) {
+        const absolutePath = path.isAbsolute(outputPath)
+          ? outputPath
+          : path.resolve(process.cwd(), outputPath);
+
+        const text = (await readFileSafe(absolutePath)) ?? (await readFileSafe(outputPath));
+        if (text) {
+          files.push({ path: absolutePath, text });
+        }
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Creates an esbuild plugin that transforms `import.meta.resolve()` calls
+ * to resolved file:// URLs at build time.
+ *
+ * This plugin is necessary because esbuild doesn't handle `import.meta.resolve()`
+ * calls during bundling - it leaves them as runtime calls. For local imports
+ * (relative paths), we need to resolve them at build time so they work correctly
+ * in the bundled output.
+ */
+export const importMetaResolvePlugin = (): Plugin => {
+  return {
+    name: 'import-meta-resolve',
+    setup(build) {
+      let entryPointDir: string | undefined;
+
+      // Transform source files during load phase
+      build.onLoad({ filter: /.*/ }, async (args) => {
+        // Track entry point directory (first non-node_modules file)
+        if (args.namespace === 'file' && !entryPointDir && !args.path.includes('node_modules')) {
+          entryPointDir = path.dirname(args.path);
+        }
+
+        // Skip node_modules
+        if (args.path.includes('node_modules')) {
+          return undefined;
+        }
+
+        // Read and transform file if it contains import.meta.resolve
+        const contents = await readFileSafe(args.path);
+        if (!contents || !contents.includes('import.meta.resolve')) {
+          return undefined;
+        }
+
+        const transformedContents = transformImportMetaResolve(contents, path.dirname(args.path));
+        if (transformedContents === contents) {
+          return undefined;
+        }
+
+        const loader = getLoader(args.path);
+        return loader ? { contents: transformedContents, loader } : undefined;
+      });
+
+      // Transform bundled output files
+      build.onEnd(async (result) => {
+        if (!entryPointDir) {
+          return;
+        }
+
+        const files = await collectOutputFiles(result);
+        const fs = await import('node:fs/promises');
+
+        for (const file of files) {
+          if (!file.text.includes('import.meta.resolve')) {
+            continue;
+          }
+
+          const transformedText = transformImportMetaResolve(file.text, entryPointDir);
+          if (transformedText !== file.text) {
+            try {
+              await fs.writeFile(file.path, transformedText, 'utf-8');
+            } catch (error) {
+              console.warn(`Failed to write transformed output to ${file.path}:`, error);
+            }
+          }
+        }
+      });
+    },
+  };
+};

package/src/import-script.ts

@@ -5,6 +5,8 @@ import { pathToFileURL } from 'node:url';
 import { processAccessError } from './error.js';
 
 import { readPackageUp } from 'read-package-up';
+import { importMetaResolvePlugin } from './import-meta-resolve-plugin.js';
+import { rawMarkdownPlugin } from './markdown-plugin.js';
 
 /**
  * Represents a Node.js module with an optional default export.
@@ -79,6 +81,9 @@ export const importScript = async <M extends EsmModule>(
         outfile,
         platform: 'node',
         write: true,
+        plugins: [importMetaResolvePlugin(), rawMarkdownPlugin()],
+        // Enable metafile so the plugin can find output files when write: true
+        metafile: true,
       },
       options, // provided options
       {
@@ -88,6 +93,9 @@ export const importScript = async <M extends EsmModule>(
         bundle: true,
         packages: 'external',
         format: 'esm',
+        // Override plugins to ensure import-meta-resolve is included
+        // Ensure metafile is enabled for the plugin to work with write: true
+        metafile: options?.metafile ?? true,
       },
     ) as BuildOptions;
 

package/src/index.ts

@@ -7,5 +7,7 @@ export {
   type ImportConfigResult,
 } from './import-config.js';
 export { resolveConfigFile } from './resolve-config-file.js';
+export { importMetaResolvePlugin as createImportMetaResolvePlugin } from './import-meta-resolve-plugin.js';
+export { rawMarkdownPlugin } from './markdown-plugin.js';
 
 export { FileNotFoundError, FileNotAccessibleError } from './error.js';

package/src/markdown-plugin.ts

@@ -0,0 +1,79 @@
+import type { Plugin } from 'esbuild';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+/**
+ * Options for configuring the markdown raw plugin.
+ */
+export interface RawMarkdownPluginOptions {
+  /**
+   * Regular expression filter to match file imports.
+   * @default /\.mdx?\?raw$/
+   */
+  filter?: RegExp;
+}
+
+/**
+ * Creates an esbuild plugin that handles `?raw` imports for markdown files.
+ *
+ * This plugin allows importing markdown files as raw strings using the `?raw` query parameter:
+ * ```typescript
+ * import readmeContent from '../../README.md?raw';
+ * import mdxContent from '../../docs/guide.mdx?raw';
+ * ```
+ *
+ * The plugin intercepts imports ending with `?raw` (or `.md?raw`/`.mdx?raw`), reads the file content,
+ * and returns it as a default export string.
+ *
+ * @param options - Configuration options for the plugin
+ * @returns An esbuild plugin
+ */
+export const rawMarkdownPlugin = (options: RawMarkdownPluginOptions = {}): Plugin => {
+  const { filter = /\.mdx?\?raw$/ } = options;
+
+  return {
+    name: 'markdown-raw',
+    setup(build) {
+      // Handle imports ending with ?raw
+      build.onResolve({ filter }, (args) => {
+        // Remove the ?raw suffix to get the actual file path
+        const filePath = args.path.replace(/\?raw$/, '');
+
+        // Determine the resolve directory: use importer's directory if available, otherwise use resolveDir
+        const resolveDir = args.importer
+          ? path.dirname(args.importer)
+          : args.resolveDir || process.cwd();
+
+        const resolvedPath = path.isAbsolute(filePath)
+          ? filePath
+          : path.resolve(resolveDir, filePath);
+
+        return {
+          path: resolvedPath,
+          namespace: 'markdown-raw',
+        };
+      });
+
+      // Load the file content as a string
+      build.onLoad({ filter: /.*/, namespace: 'markdown-raw' }, async (args) => {
+        try {
+          const content = await readFile(args.path, 'utf-8');
+          // Export the content as a default export string
+          return {
+            contents: `export default ${JSON.stringify(content)};`,
+            loader: 'js',
+          };
+        } catch (error) {
+          return {
+            errors: [
+              {
+                text: `Failed to read file: ${args.path}`,
+                detail: error instanceof Error ? error.message : String(error),
+              },
+            ],
+          };
+        }
+      });
+    },
+  };
+};

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '1.1.8';
+export const version = '1.2.0-next.0';