memory-extract 0.1.0 → 0.1.2

package/tools/playMemory.mjs

@@ -0,0 +1,10 @@
+export {
+    buildBrowseListingDocument,
+    buildInteractiveBrowseDocument,
+    buildMemoryBrowseListings,
+    collectVirtualDirectoryPaths,
+    isHtmlEntry,
+    listVirtualEntries,
+    parentVirtualPath,
+    resolveMemoryPlayMode,
+} from "../src/memoryPlay.js";

package/tools/unpack.mjs

@@ -7,21 +7,32 @@ import {
     listManifestFiles,
     readMemoryFile,
 } from "./memoryFormat.mjs";
-import { loadHostProject } from "./hostProject.mjs";
+import {
+    loadHostProject,
+    parseUnpackArgv,
+    resolveUnpackDir,
+} from "./hostProject.mjs";
 
 const parseArgs = async (argv) => {
-    const rootDir = process.cwd();
-    const host = await loadHostProject(rootDir);
-    const input = path.resolve(argv[0] ?? host.out);
-    const outDir = path.resolve(argv[1] ?? host.unpackDir);
+    const host = await loadHostProject(process.cwd());
+    const { input, out: explicitOut } = parseUnpackArgv(argv);
+
+    if (!input) {
+        throw new Error("Specify a memory PNG path.");
+    }
 
-    return { input, outDir };
+    return { input, explicitOut, host };
 };
 
 const main = async () => {
-    const { input, outDir } = await parseArgs(process.argv.slice(2));
+    const { input, explicitOut, host } = await parseArgs(process.argv.slice(2));
     const buffer = await readFile(input);
     const { png, manifest, fileBytes, version } = extractMemory(buffer);
+    const outDir = resolveUnpackDir({
+        manifestSource: manifest.source ?? "",
+        explicitOut,
+        host,
+    });
 
     await mkdir(outDir, { recursive: true });
     await writeFile(path.join(outDir, "cover.png"), png);

package/tools/packCache.mjs

@@ -1,62 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { MEMORY_VERSION } from "./memoryFormat.mjs";
-
-export const CACHE_FILE = ".memory-pack-cache.json";
-
-export const hashBuffer = (buffer) =>
-    createHash("sha256").update(buffer).digest("hex");
-
-export const buildPackFingerprint = (options, files, cover) => ({
-    cacheVersion: 1,
-    formatVersion: MEMORY_VERSION,
-    name: options.name,
-    entry: options.entry,
-    out: path.resolve(options.out),
-    exclude: [...options.exclude].sort(),
-    coverMaxSize: options.coverMaxSize,
-    coverResize: options.coverResize,
-    cover: hashBuffer(cover),
-    files: Object.fromEntries(
-        Object.keys(files)
-            .sort()
-            .map((filePath) => [filePath, hashBuffer(files[filePath])])
-    ),
-});
-
-export const fingerprintsEqual = (left, right) =>
-    JSON.stringify(left) === JSON.stringify(right);
-
-export const cachePathFor = (rootDir) => path.join(rootDir, CACHE_FILE);
-
-export const loadPackCache = async (rootDir) => {
-    try {
-        const raw = await readFile(cachePathFor(rootDir), "utf8");
-        return JSON.parse(raw);
-    } catch {
-        return null;
-    }
-};
-
-export const savePackCache = async (rootDir, fingerprint) => {
-    await writeFile(
-        cachePathFor(rootDir),
-        `${JSON.stringify({ fingerprint }, null, 2)}\n`
-    );
-};
-
-export const isPackUpToDate = async (rootDir, fingerprint, outputPath) => {
-    try {
-        await stat(outputPath);
-    } catch {
-        return false;
-    }
-
-    const cache = await loadPackCache(rootDir);
-    if (!cache?.fingerprint) {
-        return false;
-    }
-
-    return fingerprintsEqual(cache.fingerprint, fingerprint);
-};

package/tools/resizeCover.mjs

@@ -1,55 +0,0 @@
-import sharp from "sharp";
-import { inspectPng } from "./pngInspect.mjs";
-
-const DEFAULT_MAX_BYTES = 512 * 1024;
-
-export const prepareCover = async (
-    input,
-    { maxSize = 512, resize = true, maxBytes = DEFAULT_MAX_BYTES } = {}
-) => {
-    if (!resize || maxSize <= 0) {
-        return {
-            buffer: input,
-            info: inspectPng(input),
-            changed: false,
-        };
-    }
-
-    const metadata = await sharp(input).metadata();
-    const original = {
-        width: metadata.width ?? 0,
-        height: metadata.height ?? 0,
-        bytes: input.length,
-    };
-
-    const needsResize = original.width > maxSize || original.height > maxSize;
-    const needsCompress = original.bytes > maxBytes;
-
-    if (!needsResize && !needsCompress) {
-        return {
-            buffer: input,
-            info: inspectPng(input),
-            changed: false,
-        };
-    }
-
-    let pipeline = sharp(input);
-
-    if (needsResize) {
-        pipeline = pipeline.resize(maxSize, maxSize, {
-            fit: "inside",
-            withoutEnlargement: true,
-        });
-    }
-
-    const buffer = await pipeline
-        .png({ compressionLevel: 9, effort: 10 })
-        .toBuffer();
-
-    return {
-        buffer,
-        info: inspectPng(buffer),
-        changed: true,
-        from: original,
-    };
-};