browser-metro 1.0.5

package/dist/module-cache.js

@@ -0,0 +1,31 @@
+export class ModuleCache {
+    constructor() {
+        this.modules = new Map();
+        this.npmPackages = new Map();
+    }
+    getModule(id) {
+        return this.modules.get(id);
+    }
+    setModule(id, data) {
+        this.modules.set(id, data);
+    }
+    invalidateModule(id) {
+        this.modules.delete(id);
+    }
+    isValid(id, currentSourceHash) {
+        const cached = this.modules.get(id);
+        return cached !== undefined && cached.sourceHash === currentSourceHash;
+    }
+    getNpmPackage(specifier) {
+        return this.npmPackages.get(specifier);
+    }
+    setNpmPackage(specifier, code) {
+        this.npmPackages.set(specifier, code);
+    }
+    hasNpmPackage(specifier) {
+        return this.npmPackages.has(specifier);
+    }
+    invalidateNpmPackages() {
+        this.npmPackages.clear();
+    }
+}

package/dist/plugins/data-bx-path.d.ts

@@ -0,0 +1,2 @@
+import type { BundlerPlugin } from "../types.js";
+export declare function createDataBxPathPlugin(): BundlerPlugin;

package/dist/plugins/data-bx-path.js

@@ -0,0 +1,197 @@
+function isJSX(filename) {
+    return filename.endsWith(".tsx") || filename.endsWith(".jsx");
+}
+function isTagNameChar(c) {
+    return ((c >= 65 && c <= 90) ||
+        (c >= 97 && c <= 122) || // A-Z, a-z
+        (c >= 48 && c <= 57) || // 0-9
+        c === 95 ||
+        c === 46); // _, .
+}
+function isTagStartChar(c) {
+    return (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95; // A-Z, a-z, _
+}
+function isWordChar(c) {
+    return ((c >= 65 && c <= 90) ||
+        (c >= 97 && c <= 122) || // A-Z, a-z
+        (c >= 48 && c <= 57) || // 0-9
+        c === 95 ||
+        c === 36); // _, $
+}
+const JSX_KEYWORDS = new Set([
+    "return",
+    "yield",
+    "default",
+    "case",
+    "throw",
+    "new",
+    "await",
+]);
+/**
+ * Check if `<` at position `pos` is in a JSX context (not a comparison operator).
+ * Looks backwards to find the preceding non-whitespace token and decides:
+ * - After `)` or `]` -> comparison (e.g. `fn() < x`, `arr[0] < x`)
+ * - After a word char -> comparison UNLESS the word is a JSX keyword (return, yield, etc.)
+ * - After anything else (operators, brackets, =, etc.) -> JSX
+ */
+function isJsxContext(src, pos) {
+    let j = pos - 1;
+    while (j >= 0) {
+        const c = src.charCodeAt(j);
+        if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
+            break;
+        j--;
+    }
+    if (j < 0)
+        return true; // start of file
+    const c = src.charCodeAt(j);
+    // After ) or ] -> likely comparison
+    if (c === 41 || c === 93)
+        return false;
+    // After a word character -> check if it's a JSX-preceding keyword
+    if (isWordChar(c)) {
+        const end = j + 1;
+        while (j >= 0 && isWordChar(src.charCodeAt(j)))
+            j--;
+        const word = src.slice(j + 1, end);
+        return JSX_KEYWORDS.has(word);
+    }
+    // After anything else (operators, brackets, etc.) -> likely JSX
+    return true;
+}
+function injectDataBxPath(src, filename) {
+    const len = src.length;
+    let result = "";
+    let i = 0;
+    let line = 1;
+    let col = 1;
+    // State: 0=normal, 1=single-quote, 2=double-quote, 3=template, 4=line-comment, 5=block-comment
+    let state = 0;
+    while (i < len) {
+        const cc = src.charCodeAt(i);
+        // Handle escape sequences in strings/template literals
+        if ((state === 1 || state === 2 || state === 3) && cc === 92) {
+            // backslash
+            result += src[i];
+            i++;
+            col++;
+            if (i < len) {
+                result += src[i];
+                if (src.charCodeAt(i) === 10) {
+                    line++;
+                    col = 1;
+                }
+                else {
+                    col++;
+                }
+                i++;
+            }
+            continue;
+        }
+        if (state === 0) {
+            if (cc === 39) {
+                state = 1; // '
+            }
+            else if (cc === 34) {
+                state = 2; // "
+            }
+            else if (cc === 96) {
+                state = 3; // `
+            }
+            else if (cc === 47 && i + 1 < len) {
+                // /
+                const next = src.charCodeAt(i + 1);
+                if (next === 47) {
+                    state = 4; // //
+                }
+                else if (next === 42) {
+                    state = 5; // /*
+                }
+            }
+            else if (cc === 60 &&
+                i + 1 < len &&
+                isTagStartChar(src.charCodeAt(i + 1))) {
+                // Potential JSX: < followed by [A-Za-z_]
+                if (isJsxContext(src, i)) {
+                    const tagLine = line;
+                    const tagCol = col;
+                    // Emit '<'
+                    result += "<";
+                    i++;
+                    col++;
+                    // Extract tag name (supports dotted: Motion.div)
+                    let tagName = "";
+                    while (i < len && isTagNameChar(src.charCodeAt(i))) {
+                        tagName += src[i];
+                        result += src[i];
+                        i++;
+                        col++;
+                    }
+                    // Skip fragments and generics
+                    const nextCc = i < len ? src.charCodeAt(i) : 0;
+                    const isFragment = tagName === "Fragment" || tagName === "React.Fragment";
+                    const isGeneric = nextCc === 60; // followed by <
+                    if (!isFragment && !isGeneric && tagName.length > 0) {
+                        const pathVal = filename + ":" + tagLine + ":" + tagCol;
+                        const firstChar = tagName.charCodeAt(0);
+                        // Lowercase tags (HTML elements): use data- attribute (React passes it to DOM)
+                        // Uppercase/dotted tags (components): use dataSet (RNW renders as data-* on host element)
+                        if (firstChar >= 97 && firstChar <= 122) {
+                            result += ' data-bx-path="' + pathVal + '"';
+                        }
+                        else {
+                            result += ' dataSet={{"bx-path":"' + pathVal + '"}}';
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+        else if (state === 1) {
+            if (cc === 39)
+                state = 0;
+        }
+        else if (state === 2) {
+            if (cc === 34)
+                state = 0;
+        }
+        else if (state === 3) {
+            if (cc === 96)
+                state = 0;
+        }
+        else if (state === 4) {
+            if (cc === 10)
+                state = 0;
+        }
+        else if (state === 5) {
+            if (cc === 42 && i + 1 < len && src.charCodeAt(i + 1) === 47) {
+                // */
+                result += "*/";
+                col += 2;
+                i += 2;
+                state = 0;
+                continue;
+            }
+        }
+        result += src[i];
+        if (cc === 10) {
+            line++;
+            col = 1;
+        }
+        else {
+            col++;
+        }
+        i++;
+    }
+    return result;
+}
+export function createDataBxPathPlugin() {
+    return {
+        name: "data-bx-path",
+        transformSource({ src, filename }) {
+            if (!isJSX(filename))
+                return null;
+            return { src: injectDataBxPath(src, filename) };
+        },
+    };
+}

package/dist/resolver.d.ts

@@ -0,0 +1,18 @@
+import { VirtualFS } from "./fs.js";
+import { ResolverConfig } from "./types.js";
+export declare class Resolver {
+    private fs;
+    private sourceExts;
+    private pathAliases;
+    constructor(fs: VirtualFS, config: ResolverConfig);
+    /** Expand tsconfig path aliases. Returns null if no alias matched. */
+    private expandAlias;
+    /** Check if a require target is an npm package (not a relative/absolute path) */
+    isNpmPackage(target: string): boolean;
+    /** Resolve a relative require path against the current module's directory */
+    resolvePath(from: string, to: string): string;
+    /** Check if a path is an asset file (image, font, css, etc.) */
+    isAssetFile(filePath: string): boolean;
+    /** Try to find the actual file path (with extension, or index file) */
+    resolveFile(resolved: string): string | null;
+}

package/dist/resolver.js

@@ -0,0 +1,84 @@
+export class Resolver {
+    constructor(fs, config) {
+        // Compiled path aliases: [prefix to match, prefix to replace with]
+        this.pathAliases = [];
+        this.fs = fs;
+        this.sourceExts = config.sourceExts;
+        // Compile tsconfig "paths" into simple prefix pairs
+        if (config.paths) {
+            for (const [pattern, targets] of Object.entries(config.paths)) {
+                if (!targets.length)
+                    continue;
+                // "@/*" → prefix "@/", "./*" → replacement "/"
+                const from = pattern.replace(/\*$/, "");
+                const to = "/" + targets[0].replace(/^\.\/?/, "").replace(/\*$/, "");
+                this.pathAliases.push([from, to]);
+            }
+        }
+    }
+    /** Expand tsconfig path aliases. Returns null if no alias matched. */
+    expandAlias(target) {
+        for (const [from, to] of this.pathAliases) {
+            if (target.startsWith(from)) {
+                return to + target.slice(from.length);
+            }
+        }
+        return null;
+    }
+    /** Check if a require target is an npm package (not a relative/absolute path) */
+    isNpmPackage(target) {
+        if (target[0] === "." || target[0] === "/")
+            return false;
+        if (this.expandAlias(target) !== null)
+            return false;
+        return true;
+    }
+    /** Resolve a relative require path against the current module's directory */
+    resolvePath(from, to) {
+        // Expand path aliases first (e.g. "@/hooks/foo" → "/hooks/foo")
+        const expanded = this.expandAlias(to);
+        if (expanded)
+            return expanded;
+        if (this.isNpmPackage(to))
+            return to;
+        // Get directory of 'from'
+        const parts = from.split("/");
+        parts.pop(); // remove filename
+        const dir = parts.join("/") || "/";
+        // Resolve relative path
+        const segments = (dir + "/" + to).split("/").filter(Boolean);
+        const resolved = [];
+        for (let i = 0; i < segments.length; i++) {
+            if (segments[i] === "..")
+                resolved.pop();
+            else if (segments[i] !== ".")
+                resolved.push(segments[i]);
+        }
+        return "/" + resolved.join("/");
+    }
+    /** Check if a path is an asset file (image, font, css, etc.) */
+    isAssetFile(filePath) {
+        return /\.(png|jpe?g|gif|svg|webp|bmp|ico|ttf|otf|woff2?|mp[34]|wav|aac|pdf|css)$/i.test(filePath);
+    }
+    /** Try to find the actual file path (with extension, or index file) */
+    resolveFile(resolved) {
+        if (this.fs.exists(resolved))
+            return resolved;
+        // Asset files resolve to themselves even if not in VFS
+        if (this.isAssetFile(resolved))
+            return resolved;
+        // Try each configured source extension
+        for (const ext of this.sourceExts) {
+            const withExt = resolved + "." + ext;
+            if (this.fs.exists(withExt))
+                return withExt;
+        }
+        // Try index files
+        for (const ext of this.sourceExts) {
+            const indexPath = resolved + "/index." + ext;
+            if (this.fs.exists(indexPath))
+                return indexPath;
+        }
+        return null;
+    }
+}

package/dist/source-map.d.ts

@@ -0,0 +1,36 @@
+/** Source map v3 interface */
+export interface RawSourceMap {
+    version: number;
+    file?: string;
+    sources: string[];
+    sourcesContent?: string[];
+    mappings: string;
+    names: string[];
+}
+/**
+ * Decoded segment: either [genCol] (unmapped) or
+ * [genCol, srcIdx, origLine, origCol] or
+ * [genCol, srcIdx, origLine, origCol, nameIdx]
+ */
+export type Segment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export declare function encodeVLQ(value: number): string;
+export declare function decodeVLQ(str: string, offset: number): {
+    value: number;
+    next: number;
+};
+export declare function decodeMappings(mappings: string): Segment[][];
+export declare function encodeMappings(decoded: Segment[][]): string;
+export interface ModuleSourceMapInput {
+    sourceFile: string;
+    sourceContent: string;
+    map: RawSourceMap;
+    generatedLineOffset: number;
+}
+export declare function buildCombinedSourceMap(modules: ModuleSourceMapInput[]): RawSourceMap;
+export declare function inlineSourceMap(map: RawSourceMap): string;
+/**
+ * Shift all origLine values in a source map by `lineOffset`.
+ * Use negative offset to compensate for lines prepended by plugins.
+ */
+export declare function shiftSourceMapOrigLines(map: RawSourceMap, lineOffset: number): RawSourceMap;
+export declare function countNewlines(s: string): number;

package/dist/source-map.js

@@ -0,0 +1,186 @@
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_DECODE = new Array(128).fill(-1);
+for (let i = 0; i < BASE64.length; i++)
+    BASE64_DECODE[BASE64.charCodeAt(i)] = i;
+export function encodeVLQ(value) {
+    let vlq = value < 0 ? (-value << 1) | 1 : value << 1;
+    let result = "";
+    do {
+        let digit = vlq & 0x1f;
+        vlq >>>= 5;
+        if (vlq > 0)
+            digit |= 0x20;
+        result += BASE64[digit];
+    } while (vlq > 0);
+    return result;
+}
+export function decodeVLQ(str, offset) {
+    let result = 0;
+    let shift = 0;
+    let continuation;
+    let i = offset;
+    do {
+        const digit = BASE64_DECODE[str.charCodeAt(i++)];
+        continuation = (digit & 0x20) !== 0;
+        result += (digit & 0x1f) << shift;
+        shift += 5;
+    } while (continuation);
+    const isNegative = (result & 1) !== 0;
+    result >>= 1;
+    return { value: isNegative ? -result : result, next: i };
+}
+export function decodeMappings(mappings) {
+    const lines = [];
+    let srcIdx = 0;
+    let origLine = 0;
+    let origCol = 0;
+    let nameIdx = 0;
+    for (const lineStr of mappings.split(";")) {
+        const segments = [];
+        let genCol = 0;
+        if (lineStr) {
+            for (const segStr of lineStr.split(",")) {
+                if (!segStr)
+                    continue;
+                let pos = 0;
+                const fields = [];
+                while (pos < segStr.length) {
+                    const { value, next } = decodeVLQ(segStr, pos);
+                    fields.push(value);
+                    pos = next;
+                }
+                if (fields.length >= 4) {
+                    genCol += fields[0];
+                    srcIdx += fields[1];
+                    origLine += fields[2];
+                    origCol += fields[3];
+                    if (fields.length >= 5) {
+                        nameIdx += fields[4];
+                        segments.push([genCol, srcIdx, origLine, origCol, nameIdx]);
+                    }
+                    else {
+                        segments.push([genCol, srcIdx, origLine, origCol]);
+                    }
+                }
+                else if (fields.length >= 1) {
+                    genCol += fields[0];
+                    segments.push([genCol]);
+                }
+            }
+        }
+        lines.push(segments);
+    }
+    return lines;
+}
+export function encodeMappings(decoded) {
+    let prevSrcIdx = 0;
+    let prevOrigLine = 0;
+    let prevOrigCol = 0;
+    let prevNameIdx = 0;
+    const lineStrs = [];
+    for (const segments of decoded) {
+        let prevGenCol = 0;
+        const segStrs = [];
+        for (const seg of segments) {
+            let result = encodeVLQ(seg[0] - prevGenCol);
+            prevGenCol = seg[0];
+            if (seg.length >= 4) {
+                result += encodeVLQ(seg[1] - prevSrcIdx);
+                prevSrcIdx = seg[1];
+                result += encodeVLQ(seg[2] - prevOrigLine);
+                prevOrigLine = seg[2];
+                result += encodeVLQ(seg[3] - prevOrigCol);
+                prevOrigCol = seg[3];
+                if (seg.length >= 5) {
+                    result += encodeVLQ(seg[4] - prevNameIdx);
+                    prevNameIdx = seg[4];
+                }
+            }
+            segStrs.push(result);
+        }
+        lineStrs.push(segStrs.join(","));
+    }
+    return lineStrs.join(";");
+}
+export function buildCombinedSourceMap(modules) {
+    const sources = [];
+    const sourcesContent = [];
+    const names = [];
+    const allLines = [];
+    for (const mod of modules) {
+        const sourceIndex = sources.length;
+        sources.push(mod.sourceFile);
+        sourcesContent.push(mod.sourceContent);
+        const nameOffset = names.length;
+        if (mod.map.names) {
+            names.push(...mod.map.names);
+        }
+        const decoded = decodeMappings(mod.map.mappings);
+        for (let i = 0; i < decoded.length; i++) {
+            const lineIdx = mod.generatedLineOffset + i;
+            while (allLines.length <= lineIdx) {
+                allLines.push([]);
+            }
+            for (const seg of decoded[i]) {
+                if (seg.length >= 4) {
+                    let remapped;
+                    if (seg.length === 5) {
+                        remapped = [seg[0], sourceIndex, seg[2], seg[3], seg[4] + nameOffset];
+                    }
+                    else {
+                        remapped = [seg[0], sourceIndex, seg[2], seg[3]];
+                    }
+                    allLines[lineIdx].push(remapped);
+                }
+                else {
+                    allLines[lineIdx].push(seg);
+                }
+            }
+        }
+    }
+    return {
+        version: 3,
+        sources,
+        sourcesContent,
+        names,
+        mappings: encodeMappings(allLines),
+    };
+}
+function toBase64(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function inlineSourceMap(map) {
+    return ("//# sourceMappingURL=data:application/json;base64," +
+        toBase64(JSON.stringify(map)));
+}
+/**
+ * Shift all origLine values in a source map by `lineOffset`.
+ * Use negative offset to compensate for lines prepended by plugins.
+ */
+export function shiftSourceMapOrigLines(map, lineOffset) {
+    const decoded = decodeMappings(map.mappings);
+    for (const line of decoded) {
+        for (const seg of line) {
+            if (seg.length >= 4) {
+                seg[2] += lineOffset;
+            }
+        }
+    }
+    return {
+        ...map,
+        mappings: encodeMappings(decoded),
+    };
+}
+export function countNewlines(s) {
+    let count = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s.charCodeAt(i) === 10)
+            count++;
+    }
+    return count;
+}

package/dist/transforms/react-refresh.d.ts

@@ -0,0 +1,5 @@
+import { Transformer } from "../types.js";
+/** Wrap a base transformer with React Refresh instrumentation for .tsx/.jsx files */
+export declare function createReactRefreshTransformer(base: Transformer): Transformer;
+/** Pre-built React Refresh transformer wrapping the default TypeScript transformer */
+export declare const reactRefreshTransformer: Transformer;

package/dist/transforms/react-refresh.js

@@ -0,0 +1,92 @@
+import { countNewlines } from "../source-map.js";
+import { typescriptTransformer } from "./typescript.js";
+function isJsxFile(filename) {
+    return filename.endsWith(".tsx") || filename.endsWith(".jsx");
+}
+/**
+ * Detect React component names from source code.
+ * Heuristic: any function or const/let with an uppercase first letter.
+ * We scan BOTH original source (catches `export default function App`)
+ * and transformed output (catches sucrase rewrites like `function App`).
+ */
+function detectComponents(originalSrc, transformedCode) {
+    const seen = new Set();
+    const components = [];
+    // Patterns to match component-like declarations
+    const patterns = [
+        // function Foo(, export function Foo(, export default function Foo(
+        /(?:export\s+(?:default\s+)?)?function\s+([A-Z][a-zA-Z0-9]*)\s*\(/g,
+        // const Foo =, let Foo =, var Foo =  (covers arrow components, React.memo, etc.)
+        /(?:export\s+)?(?:const|let|var)\s+([A-Z][a-zA-Z0-9]*)\s*=/g,
+    ];
+    for (const src of [originalSrc, transformedCode]) {
+        for (const pattern of patterns) {
+            const re = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = re.exec(src)) !== null) {
+                const name = match[1];
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    components.push(name);
+                }
+            }
+        }
+    }
+    return components;
+}
+/** Wrap a base transformer with React Refresh instrumentation for .tsx/.jsx files */
+export function createReactRefreshTransformer(base) {
+    return {
+        transform(params) {
+            const result = base.transform(params);
+            if (!isJsxFile(params.filename)) {
+                return result;
+            }
+            const components = detectComponents(params.src, result.code);
+            if (components.length === 0) {
+                return result;
+            }
+            // Preamble: set up refresh hooks scoped to this module
+            const preamble = 'var _prevRefreshReg = window.$RefreshReg$;\n' +
+                'var _prevRefreshSig = window.$RefreshSig$;\n' +
+                'var _refreshModuleId = ' + JSON.stringify(params.filename) + ';\n' +
+                'window.$RefreshReg$ = function(type, id) {\n' +
+                '  if (window.__REACT_REFRESH_RUNTIME__) {\n' +
+                '    window.__REACT_REFRESH_RUNTIME__.register(type, _refreshModuleId + " " + id);\n' +
+                '  }\n' +
+                '};\n' +
+                'window.$RefreshSig$ = function() {\n' +
+                '  if (window.__REACT_REFRESH_RUNTIME__) {\n' +
+                '    return window.__REACT_REFRESH_RUNTIME__.createSignatureFunctionForTransform();\n' +
+                '  }\n' +
+                '  return function(type) { return type; };\n' +
+                '};\n';
+            // Postamble: register each component and accept HMR
+            let postamble = '\n';
+            for (const name of components) {
+                postamble +=
+                    'if (typeof ' + name + ' === "function") {\n' +
+                        '  $RefreshReg$(' + name + ', ' + JSON.stringify(name) + ');\n' +
+                        '}\n';
+            }
+            postamble +=
+                'window.$RefreshReg$ = _prevRefreshReg;\n' +
+                    'window.$RefreshSig$ = _prevRefreshSig;\n' +
+                    'if (module.hot) {\n' +
+                    '  module.hot.accept();\n' +
+                    '}\n';
+            // Offset source map to account for preamble lines
+            let sourceMap = result.sourceMap;
+            if (sourceMap) {
+                const preambleLines = countNewlines(preamble);
+                sourceMap = {
+                    ...sourceMap,
+                    mappings: ";".repeat(preambleLines) + sourceMap.mappings,
+                };
+            }
+            return { code: preamble + result.code + postamble, sourceMap };
+        },
+    };
+}
+/** Pre-built React Refresh transformer wrapping the default TypeScript transformer */
+export const reactRefreshTransformer = createReactRefreshTransformer(typescriptTransformer);

package/dist/transforms/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Transformer } from "../types.js";
+export declare const typescriptTransformer: Transformer;

package/dist/transforms/typescript.js

@@ -0,0 +1,20 @@
+import { transform } from "sucrase";
+export const typescriptTransformer = {
+    transform({ src, filename }) {
+        const ext = filename.slice(filename.lastIndexOf("."));
+        const transforms = ["imports"];
+        if (ext === ".ts" || ext === ".tsx")
+            transforms.unshift("typescript");
+        if (ext === ".tsx" || ext === ".jsx")
+            transforms.push("jsx");
+        const result = transform(src, {
+            transforms,
+            filePath: filename,
+            sourceMapOptions: { compiledFilename: filename },
+        });
+        return {
+            code: result.code,
+            sourceMap: result.sourceMap,
+        };
+    },
+};