@textadventures/squiffy-cli 6.0.0-alpha.20 → 6.0.0-beta.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2024 Alex Warren, textadventures.co.uk and contributors
+Copyright (c) 2014-2026 Alex Warren, textadventures.co.uk and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/external-files.js

@@ -11,8 +11,10 @@ export const externalFiles = (inputFilename) => {
             return result.filter((filename) => !includedFiles.includes(filename));
         },
         getContent: async (filename) => {
-            includedFiles.push(filename);
-            return (await fs.readFile(filename)).toString();
+            // Resolve relative paths against the base path
+            const resolvedPath = path.isAbsolute(filename) ? filename : path.join(basePath, filename);
+            includedFiles.push(resolvedPath);
+            return (await fs.readFile(resolvedPath)).toString();
         },
         getLocalFilename(filename) {
             return path.relative(basePath, filename);

package/dist/file-packager.d.ts

@@ -1,2 +1,3 @@
+import { PackageOptions } from "@textadventures/squiffy-packager";
 export declare const writeScriptFile: (inputFilename: string, outputPath: string, outputFilename: string) => Promise<false | undefined>;
-export declare const createPackageFiles: (inputFilename: string, outputPath: string, createZip: boolean) => Promise<boolean>;
+export declare const createPackageFiles: (inputFilename: string, outputPath: string, options?: PackageOptions) => Promise<boolean>;

package/dist/file-packager.js

@@ -24,20 +24,20 @@ export const writeScriptFile = async (inputFilename, outputPath, outputFilename)
     console.log(`Writing ${outputFilename}`);
     fs.writeFileSync(path.join(outputPath, outputFilename), await result.getJs());
 };
-export const createPackageFiles = async (inputFilename, outputPath, createZip) => {
+export const createPackageFiles = async (inputFilename, outputPath, options = {}) => {
     console.log("Loading " + inputFilename);
     const result = await getCompileResult(inputFilename);
     if (!result.success) {
         console.log("Failed.");
         return false;
     }
-    const pkg = await createPackage(result, createZip);
+    const pkg = await createPackage(result, options);
     const files = pkg.files;
     for (const file of Object.keys(files)) {
         console.log(`Writing ${file}`);
         fs.writeFileSync(path.join(outputPath, file), files[file]);
     }
-    if (createZip && pkg.zip) {
+    if (options.createZip && pkg.zip) {
         console.log("Writing output.zip");
         fs.writeFileSync(path.join(outputPath, "output.zip"), pkg.zip);
     }

package/dist/file-packager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file-packager.test.js

@@ -0,0 +1,179 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { writeScriptFile, createPackageFiles } from "./file-packager.js";
+import { externalFiles } from "./external-files.js";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Test fixtures directory
+const TEST_DIR = path.join(__dirname, "..", "test-fixtures");
+const OUTPUT_DIR = path.join(TEST_DIR, "output");
+beforeEach(async () => {
+    // Create test directories
+    await fs.mkdir(TEST_DIR, { recursive: true });
+    await fs.mkdir(OUTPUT_DIR, { recursive: true });
+});
+afterEach(async () => {
+    // Clean up all test files
+    try {
+        await fs.rm(TEST_DIR, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+});
+describe("file-packager", () => {
+    test("writeScriptFile creates JavaScript file", async () => {
+        // Create a simple test story
+        const testStory = path.join(TEST_DIR, "simple.squiffy");
+        await fs.writeFile(testStory, `
+@title Simple Test
+
+[[start]]:
+Hello world!
+
+[[next]]:
+This is a test.
+`);
+        const result = await writeScriptFile(testStory, OUTPUT_DIR, "story.js");
+        expect(result).not.toBe(false);
+        // Check that story.js was created
+        const storyPath = path.join(OUTPUT_DIR, "story.js");
+        const storyContent = await fs.readFile(storyPath, "utf8");
+        expect(storyContent).toContain("var story");
+        expect(storyContent).toContain("start");
+        expect(storyContent).toContain("Hello world!");
+    });
+    test("writeScriptFile with custom filename", async () => {
+        const testStory = path.join(TEST_DIR, "custom.squiffy");
+        await fs.writeFile(testStory, `
+@title Custom
+
+[[section]]:
+Content here.
+`);
+        await writeScriptFile(testStory, OUTPUT_DIR, "custom-story.js");
+        // Check that custom-story.js was created
+        const exists = await fs.access(path.join(OUTPUT_DIR, "custom-story.js"))
+            .then(() => true)
+            .catch(() => false);
+        expect(exists).toBe(true);
+    });
+    test("writeScriptFile handles compilation errors", async () => {
+        // Create a story with errors (passage without section)
+        const testStory = path.join(TEST_DIR, "error.squiffy");
+        await fs.writeFile(testStory, `
+[my passage]:
+This is invalid - passage without section.
+`);
+        const result = await writeScriptFile(testStory, OUTPUT_DIR, "story.js");
+        expect(result).toBe(false);
+        // story.js should not have been created
+        const exists = await fs.access(path.join(OUTPUT_DIR, "story.js"))
+            .then(() => true)
+            .catch(() => false);
+        expect(exists).toBe(false);
+    });
+    test("createPackageFiles creates full package", async () => {
+        const testStory = path.join(TEST_DIR, "package.squiffy");
+        await fs.writeFile(testStory, `
+@title Package Test
+
+[[main]]:
+This is a complete story.
+
+[Click here]:
+You clicked!
+`);
+        const result = await createPackageFiles(testStory, OUTPUT_DIR, {});
+        expect(result).toBe(true);
+        // Check that all package files were created
+        const files = await fs.readdir(OUTPUT_DIR);
+        expect(files).toContain("index.html");
+        expect(files).toContain("style.css");
+        expect(files).toContain("story.js");
+        expect(files).toContain("squiffy.runtime.global.js");
+        // Verify content
+        const html = await fs.readFile(path.join(OUTPUT_DIR, "index.html"), "utf8");
+        expect(html).toContain("Package Test");
+        expect(html).toContain("<script");
+        const js = await fs.readFile(path.join(OUTPUT_DIR, "story.js"), "utf8");
+        expect(js).toContain("var story");
+    });
+    test("createPackageFiles creates zip file", async () => {
+        const testStory = path.join(TEST_DIR, "zip.squiffy");
+        await fs.writeFile(testStory, `
+@title Zip Test
+
+[[section]]:
+Content for zip test.
+`);
+        const result = await createPackageFiles(testStory, OUTPUT_DIR, { createZip: true });
+        expect(result).toBe(true);
+        // Check that zip file was created
+        const files = await fs.readdir(OUTPUT_DIR);
+        expect(files).toContain("output.zip");
+        // Verify zip file has content
+        const zipStats = await fs.stat(path.join(OUTPUT_DIR, "output.zip"));
+        expect(zipStats.size).toBeGreaterThan(0);
+    });
+    test("createPackageFiles handles compilation errors", async () => {
+        const testStory = path.join(TEST_DIR, "error2.squiffy");
+        await fs.writeFile(testStory, `
+[[section]]:
+Some content.
+
+@ui
+This should fail - text in @ui block
+`);
+        const result = await createPackageFiles(testStory, OUTPUT_DIR, {});
+        expect(result).toBe(false);
+        // No files should have been created
+        const files = await fs.readdir(OUTPUT_DIR);
+        expect(files.length).toBe(0);
+    });
+});
+describe("external-files", () => {
+    test("getMatchingFilenames finds files by pattern", async () => {
+        // Create some test files
+        await fs.writeFile(path.join(TEST_DIR, "test1.txt"), "content 1");
+        await fs.writeFile(path.join(TEST_DIR, "test2.txt"), "content 2");
+        await fs.writeFile(path.join(TEST_DIR, "other.md"), "markdown");
+        const testFile = path.join(TEST_DIR, "main.squiffy");
+        const ext = externalFiles(testFile);
+        const matches = await ext.getMatchingFilenames("*.txt");
+        expect(matches.length).toBe(2);
+        expect(matches.some(f => f.includes("test1.txt"))).toBe(true);
+        expect(matches.some(f => f.includes("test2.txt"))).toBe(true);
+        expect(matches.some(f => f.includes("other.md"))).toBe(false);
+    });
+    test("getContent reads file content", async () => {
+        const contentFile = path.join(TEST_DIR, "content.txt");
+        await fs.writeFile(contentFile, "Hello from external file!");
+        const testFile = path.join(TEST_DIR, "main.squiffy");
+        const ext = externalFiles(testFile);
+        const content = await ext.getContent(contentFile);
+        expect(content).toBe("Hello from external file!");
+    });
+    test("getLocalFilename returns relative path", () => {
+        const testFile = path.join(TEST_DIR, "main.squiffy");
+        const ext = externalFiles(testFile);
+        const absolutePath = path.join(TEST_DIR, "subdir", "file.js");
+        const localPath = ext.getLocalFilename(absolutePath);
+        expect(localPath).toBe(path.join("subdir", "file.js"));
+    });
+    test("getMatchingFilenames excludes already included files", async () => {
+        const file1 = path.join(TEST_DIR, "included.txt");
+        const file2 = path.join(TEST_DIR, "notincluded.txt");
+        await fs.writeFile(file1, "already included");
+        await fs.writeFile(file2, "not yet included");
+        const testFile = path.join(TEST_DIR, "main.squiffy");
+        const ext = externalFiles(testFile);
+        // Simulate including file1
+        await ext.getContent(file1);
+        const matches = await ext.getMatchingFilenames("*.txt");
+        // Should only find file2, not file1 (already included)
+        expect(matches.length).toBe(1);
+        expect(matches[0]).toContain("notincluded.txt");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { externalFiles } from "./external-files.js";
+export { createPackageFiles, writeScriptFile } from "./file-packager.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+// Public API exports for programmatic use
+export { externalFiles } from "./external-files.js";
+export { createPackageFiles, writeScriptFile } from "./file-packager.js";

package/dist/squiffy.js

@@ -15,13 +15,15 @@ const argv = yargs(hideBin(process.argv))
     .describe("p", "Port for HTTP server (only with --serve)")
     .describe("scriptonly", "Only generate JavaScript file (and optionally specify a name)")
     .describe("zip", "Create zip file")
+    .describe("inline", "Create single HTML file with everything inlined")
     .version(version)
     .parseSync();
 console.log("Squiffy " + version);
 const options = {
     serve: argv.s,
     scriptOnly: argv.scriptonly,
-    zip: argv.zip
+    zip: argv.zip,
+    inline: argv.inline
 };
 const inputFilename = argv._[0];
 const outputPath = path.resolve(path.dirname(inputFilename));
@@ -30,7 +32,10 @@ if (options.scriptOnly) {
     await writeScriptFile(inputFilename, outputPath, outputFilename);
 }
 else {
-    const result = await createPackageFiles(inputFilename, outputPath, !!options.zip);
+    const result = await createPackageFiles(inputFilename, outputPath, {
+        createZip: !!options.zip,
+        inlineHtml: !!options.inline
+    });
     if (result && options.serve) {
         const port = argv.p || 8282;
         serve(outputPath, port);

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "@textadventures/squiffy-cli",
-  "version": "6.0.0-alpha.20",
+  "version": "6.0.0-beta.0",
   "publishConfig": {
     "access": "public"
   },
-  "main": "dist/squiffy.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest --run",
+    "dev": "vitest"
   },
   "author": "Alex Warren",
   "contributors": [
@@ -20,12 +30,12 @@
     "squiffy-packager": "dist/squiffy.js"
   },
   "dependencies": {
-    "@textadventures/squiffy-packager": "^6.0.0-alpha.20",
+    "@textadventures/squiffy-packager": "^6.0.0-beta.0",
     "finalhandler": "^2.1.0",
     "glob": "^11.0.3",
     "serve-static": "^2.2.0",
-    "squiffy-compiler": "^6.0.0-alpha.20",
-    "squiffy-runtime": "^6.0.0-alpha.20",
+    "squiffy-compiler": "^6.0.0-beta.0",
+    "squiffy-runtime": "^6.0.0-beta.0",
     "yargs": "^18.0.0"
   },
   "devDependencies": {
@@ -34,11 +44,12 @@
     "@types/serve-static": "^1.15.8",
     "@types/yargs": "^17.0.33",
     "tsx": "^4.20.4",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
   },
   "files": [
     "dist"
   ],
   "type": "module",
-  "gitHead": "eee4b8836ed791b68d8d56b0d5071129e6214d2b"
+  "gitHead": "dadcab6940e5e7ffdd600e8821c9297fdbf93160"
 }