memory-extract 0.1.0 → 0.1.1

package/tools/hostProject.mjs

@@ -1,7 +1,68 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 
-const DEFAULT_EXCLUDE = ["**/*.map"];
+const DEFAULT_EXCLUDE = [
+    "**/*.map",
+    "node_modules",
+    "node_modules/**",
+    ".git",
+    ".git/**",
+];
+const DEFAULT_PATH = ".";
+
+const isFlag = (arg) => arg.startsWith("-");
+
+export const parsePackArgv = (argv, defaultInput = DEFAULT_PATH) => {
+    let inputPath = defaultInput;
+    let outName = "";
+    let index = 0;
+
+    const first = argv[index];
+    if (first && !isFlag(first)) {
+        inputPath = first;
+        index += 1;
+
+        const second = argv[index];
+        if (second && !isFlag(second)) {
+            outName = second;
+            index += 1;
+        }
+    }
+
+    return {
+        input: path.resolve(inputPath),
+        outName,
+        argv: argv.slice(index),
+    };
+};
+
+export const parseUnpackArgv = (argv) => {
+    const positional = [];
+    const remaining = [];
+
+    for (const arg of argv) {
+        if (isFlag(arg)) {
+            remaining.push(arg);
+            continue;
+        }
+
+        if (positional.length < 2) {
+            positional.push(arg);
+            continue;
+        }
+
+        remaining.push(arg);
+    }
+
+    return {
+        input: positional[0] ? path.resolve(positional[0]) : "",
+        out: positional[1] ? path.resolve(positional[1]) : "",
+        argv: remaining,
+    };
+};
+
+export const resolveProjectPath = (rootDir, targetPath = "") =>
+    path.resolve(rootDir, targetPath);
 
 export const loadHostProject = async (rootDir = process.cwd()) => {
     try {
@@ -12,34 +73,91 @@ export const loadHostProject = async (rootDir = process.cwd()) => {
         const dist = path.resolve(rootDir, memory.dist ?? "dist");
         const out = memory.out
             ? path.resolve(rootDir, memory.out)
-            : path.join(dist, `${name}.png`);
+            : "";
 
         return {
+            root: rootDir,
             name,
             dist,
             out,
             cover: memory.cover ? path.resolve(rootDir, memory.cover) : "",
             entry: memory.entry ?? "index.html",
             exclude: [...new Set([...DEFAULT_EXCLUDE, ...(memory.exclude ?? [])])],
-            coverMaxSize: memory.coverMaxSize ?? 512,
-            coverResize: memory.coverResize !== false,
-            cache: memory.cache !== false,
             unpackDir: memory.unpackDir
                 ? path.resolve(rootDir, memory.unpackDir)
-                : path.join(dist, "unpack"),
+                : "",
         };
     } catch {
         return {
+            root: rootDir,
             name: "memory",
             dist: path.resolve(rootDir, "dist"),
-            out: path.resolve(rootDir, "dist", "memory.png"),
+            out: "",
             cover: "",
             entry: "index.html",
             exclude: [...DEFAULT_EXCLUDE],
-            coverMaxSize: 512,
-            coverResize: true,
-            cache: true,
-            unpackDir: path.resolve(rootDir, "dist", "unpack"),
+            unpackDir: "",
         };
     }
 };
+
+export const resolveInputIdentity = (inputPath, { isFile = false } = {}) => {
+    const resolved = path.resolve(inputPath);
+    const baseName = path.basename(resolved);
+
+    if (isFile) {
+        const extension = path.extname(baseName);
+        return extension ? baseName.slice(0, -extension.length) : baseName;
+    }
+
+    return baseName;
+};
+
+export const prefixFilePaths = (files, prefix) => {
+    if (!prefix) {
+        return files;
+    }
+
+    const normalized = prefix.replace(/\\/g, "/");
+
+    return Object.fromEntries(
+        Object.entries(files).map(([filePath, buffer]) => [
+            filePath ? `${normalized}/${filePath}` : normalized,
+            buffer,
+        ])
+    );
+};
+
+export const resolvePackSource = (projectPath, inputPath, { isFile = false } = {}) => {
+    if (isFile) {
+        return "";
+    }
+
+    const relative = path.relative(projectPath, path.resolve(inputPath));
+
+    if (!relative || relative === ".") {
+        return "";
+    }
+
+    return relative.split(path.sep).join("/");
+};
+
+export const resolveUnpackDir = ({
+    manifestSource,
+    explicitOut,
+    host,
+}) => {
+    if (explicitOut) {
+        return path.resolve(explicitOut);
+    }
+
+    if (host.unpackDir) {
+        return host.unpackDir;
+    }
+
+    if (manifestSource) {
+        return path.join(host.root ?? process.cwd(), manifestSource);
+    }
+
+    return host.root ?? process.cwd();
+};

package/tools/memoryFormat.mjs

@@ -115,12 +115,14 @@ export const buildManifest = ({
     files,
     kind = "web-app",
     runtime = "iframe-sandbox",
+    source = "",
 }) => ({
     v: 1,
     kind,
     name,
     entry,
     runtime,
+    ...(source ? { source } : {}),
     files,
 });
 
@@ -136,6 +138,7 @@ export const encodeMemoryPayload = ({
     files,
     kind = "web-app",
     runtime = "iframe-sandbox",
+    source = "",
     version = MEMORY_VERSION,
 }) => {
     if (version === 1) {
@@ -145,7 +148,14 @@ export const encodeMemoryPayload = ({
             encodedFiles[filePath] = encodeManifestFile(buffer, filePath);
         }
 
-        const manifest = buildManifest({ name, entry, files: encodedFiles, kind, runtime });
+        const manifest = buildManifest({
+            name,
+            entry,
+            files: encodedFiles,
+            kind,
+            runtime,
+            source,
+        });
 
         return {
             version: 1,
@@ -158,8 +168,8 @@ export const encodeMemoryPayload = ({
         throw new Error(`Unsupported memory version: ${version}`);
     }
 
-    const archive = encodeV2Archive({ name, entry, files, kind, runtime });
-    const { manifest } = buildV2Manifest({ name, entry, files, kind, runtime });
+    const archive = encodeV2Archive({ name, entry, files, kind, runtime, source });
+    const { manifest } = buildV2Manifest({ name, entry, files, kind, runtime, source });
 
     return {
         version: 2,

package/tools/pack.mjs

@@ -3,13 +3,13 @@ import { readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createBlankCover } from "./blankCover.mjs";
 import { matchesAnyGlob } from "./glob.mjs";
-import { loadHostProject } from "./hostProject.mjs";
 import {
-    buildPackFingerprint,
-    isPackUpToDate,
-    savePackCache,
-} from "./packCache.mjs";
-import { prepareCover } from "./resizeCover.mjs";
+    loadHostProject,
+    parsePackArgv,
+    prefixFilePaths,
+    resolveInputIdentity,
+    resolveProjectPath,
+} from "./hostProject.mjs";
 import {
     embedMemory,
     encodeMemoryPayload,
@@ -27,6 +27,21 @@ const shouldSkipPath = (absolutePath, skipPaths) => {
     });
 };
 
+const shouldExcludePath = (relativePath, excludePatterns) => {
+    if (matchesAnyGlob(relativePath, excludePatterns)) {
+        return true;
+    }
+
+    return excludePatterns.some((pattern) => {
+        if (!pattern.endsWith("/**")) {
+            return false;
+        }
+
+        const root = pattern.slice(0, -3);
+        return relativePath === root || relativePath.startsWith(`${root}/`);
+    });
+};
+
 const collectFiles = async (dir, baseDir, skipPaths, excludePatterns) => {
     const entries = await readdir(dir, { withFileTypes: true });
     const files = {};
@@ -40,16 +55,33 @@ const collectFiles = async (dir, baseDir, skipPaths, excludePatterns) => {
             continue;
         }
 
+        const relativePath = path.relative(baseDir, absolutePath)
+            .split(path.sep)
+            .join("/");
+
         if (entry.isDirectory()) {
+            if (shouldExcludePath(relativePath, excludePatterns)) {
+                continue;
+            }
+
             subdirs.push(absolutePath);
             continue;
         }
 
-        const relativePath = path.relative(baseDir, absolutePath)
-            .split(path.sep)
-            .join("/");
+        if (entry.isSymbolicLink()) {
+            const linkStat = await stat(absolutePath);
+
+            if (linkStat.isDirectory()) {
+                if (shouldExcludePath(relativePath, excludePatterns)) {
+                    continue;
+                }
 
-        if (matchesAnyGlob(relativePath, excludePatterns)) {
+                subdirs.push(absolutePath);
+                continue;
+            }
+        }
+
+        if (shouldExcludePath(relativePath, excludePatterns)) {
             continue;
         }
 
@@ -75,67 +107,120 @@ const collectFiles = async (dir, baseDir, skipPaths, excludePatterns) => {
 };
 
 const buildSkipPaths = (options) =>
-    [options.out, path.join(path.resolve(options.dist), "unpack")].map((entry) =>
-        path.resolve(entry)
-    );
+    [options.out, `${options.out}.tmp`].map((entry) => path.resolve(entry));
+
+const resolveEntry = (files, preferredEntry) => {
+    const filePaths = Object.keys(files).sort();
+
+    if (filePaths.length === 0) {
+        throw new Error("No files to pack.");
+    }
+
+    if (files[preferredEntry]) {
+        return preferredEntry;
+    }
+
+    const htmlEntry = filePaths.find((filePath) => filePath.endsWith(".html"));
+    if (htmlEntry) {
+        return htmlEntry;
+    }
+
+    return filePaths[0];
+};
+
+const collectInput = async (inputPath, skipPaths, excludePatterns) => {
+    let inputStat;
+
+    try {
+        inputStat = await stat(inputPath);
+    } catch {
+        throw new Error(`Input not found at ${inputPath}.`);
+    }
+
+    if (inputStat.isFile()) {
+        const relativePath = path.basename(inputPath);
+        return {
+            files: {
+                [relativePath]: await readFile(inputPath),
+            },
+            entry: relativePath,
+            source: "",
+        };
+    }
+
+    if (inputStat.isDirectory()) {
+        return {
+            files: await collectFiles(inputPath, inputPath, skipPaths, excludePatterns),
+            entry: "",
+            source: "",
+        };
+    }
+
+    throw new Error(`Input is not a file or directory: ${inputPath}`);
+};
+
+const ensurePngExtension = (fileName) =>
+    fileName.toLowerCase().endsWith(".png") ? fileName : `${fileName}.png`;
 
 const parseArgs = async (argv) => {
-    const rootDir = process.cwd();
-    const host = await loadHostProject(rootDir);
+    const projectPath = process.cwd();
+    const host = await loadHostProject(projectPath);
+    const { input: defaultInput, outName, argv: packArgv } = parsePackArgv(argv);
     const options = {
-        root: rootDir,
-        dist: host.dist,
+        root: projectPath,
+        input: defaultInput,
+        outName,
         cover: host.cover,
         out: host.out,
         name: host.name,
         entry: host.entry,
         exclude: [...host.exclude],
-        coverMaxSize: host.coverMaxSize,
-        coverResize: host.coverResize,
-        cache: host.cache,
-        force: false,
-        check: false,
+        entryExplicit: false,
+        nameExplicit: false,
+        outExplicit: Boolean(host.out),
     };
 
-    for (let index = 0; index < argv.length; index += 1) {
-        const arg = argv[index];
-        if (arg === "--root") {
-            options.root = path.resolve(argv[index + 1] ?? "");
-            index += 1;
-        } else if (arg === "--dist") {
-            options.dist = path.resolve(argv[index + 1] ?? "");
+    for (let index = 0; index < packArgv.length; index += 1) {
+        const arg = packArgv[index];
+        if (arg === "--input" || arg === "--dist") {
+            options.input = resolveProjectPath(projectPath, packArgv[index + 1] ?? "");
             index += 1;
         } else if (arg === "--cover") {
-            options.cover = path.resolve(argv[index + 1] ?? "");
+            options.cover = resolveProjectPath(projectPath, packArgv[index + 1] ?? "");
             index += 1;
         } else if (arg === "--out") {
-            options.out = path.resolve(argv[index + 1] ?? "");
+            options.out = resolveProjectPath(projectPath, packArgv[index + 1] ?? "");
+            options.outExplicit = true;
             index += 1;
         } else if (arg === "--name") {
-            options.name = argv[index + 1] ?? options.name;
+            options.name = packArgv[index + 1] ?? options.name;
+            options.nameExplicit = true;
             index += 1;
         } else if (arg === "--entry") {
-            options.entry = argv[index + 1] ?? options.entry;
+            options.entry = packArgv[index + 1] ?? options.entry;
+            options.entryExplicit = true;
             index += 1;
         } else if (arg === "--exclude") {
-            options.exclude.push(argv[index + 1] ?? "");
-            index += 1;
-        } else if (arg === "--cover-max-size") {
-            options.coverMaxSize = Number(argv[index + 1] ?? options.coverMaxSize);
+            options.exclude.push(packArgv[index + 1] ?? "");
             index += 1;
-        } else if (arg === "--no-cover-resize") {
-            options.coverResize = false;
-        } else if (arg === "--no-cache") {
-            options.cache = false;
-        } else if (arg === "--force") {
-            options.force = true;
-        } else if (arg === "--check") {
-            options.check = true;
         }
     }
 
     options.exclude = [...new Set(options.exclude.filter(Boolean))];
 
+    if (options.outName && !options.outExplicit) {
+        options.out = resolveProjectPath(
+            projectPath,
+            ensurePngExtension(options.outName)
+        );
+        options.outExplicit = true;
+    }
+
+    if (options.outName && !options.nameExplicit) {
+        options.name = options.outName;
+        options.nameExplicit = true;
+    }
+
     return options;
 };
 
@@ -143,29 +228,21 @@ const formatKb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
 
 const main = async () => {
     const options = await parseArgs(process.argv.slice(2));
+    const inputStat = await stat(options.input);
+    const inputIsFile = inputStat.isFile();
+    const identity = resolveInputIdentity(options.input, { isFile: inputIsFile });
 
-    try {
-        await stat(options.dist);
-    } catch {
-        throw new Error(`Build output not found at ${options.dist}. Run your build first.`);
+    if (!options.nameExplicit) {
+        options.name = identity;
+    }
+
+    if (!options.outExplicit) {
+        options.out = path.join(options.root, `${identity}.png`);
     }
 
     let cover;
     if (options.cover) {
-        const sourceCover = await readFile(options.cover);
-        const prepared = await prepareCover(sourceCover, {
-            maxSize: options.coverMaxSize,
-            resize: options.coverResize,
-        });
-
-        cover = prepared.buffer;
-
-        if (prepared.changed && prepared.from && prepared.info) {
-            console.log(
-                `Resized cover from ${prepared.from.width}x${prepared.from.height} (${formatKb(prepared.from.bytes)}) to ${prepared.info.width}x${prepared.info.height} (${formatKb(prepared.info.bytes)})`
-            );
-        }
-
+        cover = await readFile(options.cover);
         console.log(`Using cover image ${options.cover}`);
     } else {
         cover = createBlankCover();
@@ -173,48 +250,31 @@ const main = async () => {
     }
 
     const skipPaths = buildSkipPaths(options);
-    const files = await collectFiles(
-        options.dist,
-        options.dist,
+    const collected = await collectInput(
+        options.input,
         skipPaths,
         options.exclude
     );
+    let { files, entry: fileEntry } = collected;
+    const preferredEntry = inputIsFile
+        ? options.entry
+        : path.posix.join(identity, options.entry);
 
-    if (!files[options.entry]) {
-        throw new Error(
-            `Entry not found in dist: ${options.entry}. Checked ${Object.keys(files).length} files.`
-        );
-    }
-
-    const fingerprint = buildPackFingerprint(options, files, cover);
-
-    if (options.check && !options.cache) {
-        throw new Error("Pack cache is disabled. Remove --check or enable cache in memory config.");
+    if (!inputIsFile) {
+        files = prefixFilePaths(files, identity);
     }
 
-    const upToDate =
-        options.cache &&
-        !options.force &&
-        (await isPackUpToDate(options.root, fingerprint, options.out));
+    const entry = fileEntry || resolveEntry(files, preferredEntry);
 
-    if (options.check) {
-        if (upToDate) {
-            console.log(`Memory pack is up to date: ${options.out}`);
-            return;
-        }
-
-        console.error(`Memory pack is stale: ${options.out}`);
-        process.exit(1);
-    }
-
-    if (upToDate) {
-        console.log(`Memory unchanged, skipping pack: ${options.out}`);
-        return;
+    if (options.entryExplicit && !files[options.entry]) {
+        throw new Error(
+            `Entry not found: ${options.entry}. Checked ${Object.keys(files).length} files.`
+        );
     }
 
     const { payload, version } = encodeMemoryPayload({
         name: options.name,
-        entry: options.entry,
+        entry,
         files,
     });
     const memory = embedMemory(cover, payload, version);
@@ -223,12 +283,8 @@ const main = async () => {
     await writeFile(tempPath, memory);
     await rename(tempPath, options.out);
 
-    if (options.cache) {
-        await savePackCache(options.root, fingerprint);
-    }
-
     console.log(
-        `Packed ${Object.keys(files).length} files into ${options.out} (${formatKb(memory.length)})`
+        `Packed ${Object.keys(files).length} files from ${options.input} into ${options.out} (${formatKb(memory.length)})`
     );
     console.log(`  cover: ${formatKb(cover.length)}, payload: ${formatKb(payload.length)}, format: v${version}`);
 };