extwee 2.2.6 → 2.3.0

package/test/Config/isFile.test.js

@@ -0,0 +1,50 @@
+import { isFile } from '../../src/CLI/isFile.js';
+import { statSync } from 'node:fs';
+
+// Mock the statSync function from 'fs'.
+jest.mock('node:fs', () => ({
+    statSync: jest.fn(),
+}));
+
+describe('isFile', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return true if the path is a valid file', () => {
+        // Mock statSync to return an object with isFile() returning true.
+        statSync.mockReturnValue({
+            isFile: jest.fn(() => true),
+        });
+
+        const result = isFile('/path/to/file');
+        expect(result).toBe(true);
+        expect(statSync).toHaveBeenCalledWith('/path/to/file');
+    });
+
+    it('should return false if the path is not a valid file', () => {
+        // Mock statSync to return an object with isFile() returning false.
+        statSync.mockReturnValue({
+            isFile: jest.fn(() => false),
+        });
+
+        const result = isFile('/path/to/directory');
+        expect(result).toBe(false);
+        expect(statSync).toHaveBeenCalledWith('/path/to/directory');
+    });
+
+    it('should return false and log an error if statSync throws an error', () => {
+        // Mock statSync to throw an error.
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+        statSync.mockImplementation(() => {
+            throw new Error('File not found');
+        });
+
+        const result = isFile('/invalid/path');
+        expect(result).toBe(false);
+        expect(statSync).toHaveBeenCalledWith('/invalid/path');
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error: Error: File not found'));
+
+        consoleErrorSpy.mockRestore();
+    });
+});

package/test/Config/loadStoryFormat.test.js

@@ -0,0 +1,101 @@
+import { loadStoryFormat } from "../../src/CLI/ProcessConfig/loadStoryFormat.js";
+import { isDirectory } from "../../src/CLI/isDirectory.js";
+import { isFile } from "../../src/CLI/isFile.js";
+import { readDirectories } from "../../src/CLI/ProcessConfig/readDirectories.js";
+import { readFileSync } from "node:fs";
+
+jest.mock("../../src/CLI/isDirectory.js");
+jest.mock("../../src/CLI/isFile.js");
+jest.mock("../../src/CLI/ProcessConfig/readDirectories.js");
+jest.mock("node:fs");
+
+describe("loadStoryFormat", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should throw an error if the story-formats directory does not exist", () => {
+        isDirectory.mockReturnValueOnce(false);
+
+        expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
+            "Error: story-formats directory does not exist. Consider running 'npx sfa-get' to download the latest story formats."
+        );
+    });
+
+    it("should throw an error if the named story format directory does not exist", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(false);
+
+        expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
+            "Error: story format Harlowe does not exist in the story-formats directory."
+        );
+    });
+
+    it("should throw an error if the version directory does not exist", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(false);
+
+        expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
+            "Error: story format Harlowe version 3.2.0 does not exist in the story-formats directory."
+        );
+    });
+
+    it("should throw an error if the format.js file does not exist in the version directory", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(false);
+
+        expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
+            "Error: story format Harlowe version 3.2.0 does not have a format.js file."
+        );
+    });
+
+    it("should return the contents of the format.js file if all checks pass", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(true);
+        readFileSync.mockReturnValueOnce("format.js content");
+
+        const result = loadStoryFormat("Harlowe", "3.2.0");
+        expect(result).toBe("format.js content");
+    });
+
+    it("should handle 'latest' version and return the contents of the format.js file", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(false).mockReturnValueOnce(true);
+        readDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
+        readFileSync.mockReturnValueOnce("latest format.js content");
+
+        const result = loadStoryFormat("Harlowe", "latest");
+        expect(result).toBe("latest format.js content");
+        expect(readDirectories).toHaveBeenCalledWith("story-formats/Harlowe");
+    });
+
+    it("should throw an error if 'latest' version has no format.js file", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(false).mockReturnValueOnce(false);
+        readDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
+
+        expect(() => loadStoryFormat("Harlowe", "latest")).toThrow(
+            "Error: story format Harlowe version latest does not have a format.js file."
+        );
+    });
+
+    it("should read format.js file from the story format directory if it exists", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(true);
+        readDirectories.mockReturnValueOnce([]);
+        readFileSync.mockReturnValueOnce("latest format.js content");
+
+        const result = loadStoryFormat("Harlowe", "latest");
+        expect(result).toBe("latest format.js content");
+        expect(readFileSync).toHaveBeenCalledWith("story-formats/Harlowe/format.js", "utf-8");
+    });
+
+    it("should throw an error if the story format version is not 'latest' and version directories do not exist", () => {
+        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        isFile.mockReturnValueOnce(false);
+        readDirectories.mockReturnValueOnce([]);
+
+        expect(() => loadStoryFormat("Harlowe", "latest")).toThrow(
+            `Error: story format Harlowe does not have any version directories.`
+        );
+    }
+    );
+});

package/test/Config/readDirectories.test.js

@@ -0,0 +1,68 @@
+import { readDirectories } from '../../src/CLI/ProcessConfig/readDirectories.js';
+import { readdirSync } from 'node:fs';
+import { isDirectory } from '../../src/CLI/isDirectory.js';
+
+jest.mock('node:fs');
+jest.mock('../../src/CLI/isDirectory.js');
+
+describe('readDirectories', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return an empty array and log an error if the directory does not exist', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+        isDirectory.mockReturnValue(false);
+
+        const result = readDirectories('/nonexistent');
+
+        expect(result).toEqual([]);
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Directory /nonexistent does not exist.');
+        consoleErrorSpy.mockRestore();
+    });
+
+    it('should return an empty array and log an error if readdirSync throws an error', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+        isDirectory.mockReturnValue(true);
+        readdirSync.mockImplementation(() => {
+            throw new Error('Permission denied');
+        });
+
+        const result = readDirectories('/restricted');
+
+        expect(result).toEqual([]);
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error reading directory /restricted:', expect.any(Error));
+        consoleErrorSpy.mockRestore();
+    });
+
+    it('should return an empty array if the directory is empty', () => {
+        isDirectory.mockReturnValue(true);
+        readdirSync.mockReturnValue([]);
+
+        const result = readDirectories('/empty');
+
+        expect(result).toEqual([]);
+    });
+
+    it('should return an array of directories', () => {
+        isDirectory.mockReturnValue(true);
+        readdirSync.mockReturnValue(['dir1', 'file1', 'dir2']);
+
+        isDirectory.mockImplementation((path) => {
+            return path === '/test/dir1' || path === '/test/dir2';
+        });
+
+        const result = readDirectories('/test');
+
+        expect(result).toEqual(['dir1', 'dir2']);
+    });
+    
+    it('should return an empty array if the result is not an array', () => {
+        isDirectory.mockReturnValue(true);
+        readdirSync.mockReturnValue('not an array');
+
+        const result = readDirectories('/test');
+
+        expect(result).toEqual([]);
+    });
+});

package/test/Objects/Passage.test.js

@@ -240,5 +240,10 @@ describe('Passage', () => {
       expect(t.querySelector('tw-passagedata').getAttribute('tags')).toBe('&tag "bad"');
       expect(t.querySelector('tw-passagedata').getAttribute('position')).toBe('100,100');
     });
+
+    it('Should escape double-colon at start of text when exporting to Twee', function () {
+      const p = new Passage('test', ':: nefarious');
+      expect(p.toTwee()).toBe(':: test\n\\:: nefarious\n\n');
+    });
   });
 });

package/test/Objects/Story.test.js

@@ -229,6 +229,45 @@ describe('Story', () => {
     });
   });
 
+  describe('storyStylesheet', () => {
+    let s = null;
+
+    beforeEach(() => {
+      s = new Story();
+    });
+
+    it('Set storyStylesheet', () => {
+      s.storyStylesheet = 'Test';
+      expect(s.storyStylesheet).not.toBe('');
+    });
+
+    it('Should throw error if not String', () => {
+      expect(() => {
+        s.storyStylesheet = 1;
+      }).toThrow();
+    }
+    );
+  });
+
+  describe('storyJavaScript', () => {
+    let s = null;
+
+    beforeEach(() => {
+      s = new Story();
+    });
+
+    it('Set storyJavaScript', () => {
+      s.storyJavaScript = 'Test';
+      expect(s.storyJavaScript).not.toBe('');
+    });
+
+    it('Should throw error if not String', () => {
+      expect(() => {
+        s.storyJavaScript = 1;
+      }).toThrow();
+    });
+  });
+
   describe('passages', () => {
     let s = null;
 
@@ -442,6 +481,30 @@ describe('Story', () => {
       // Should have a single passage.
       expect(result.passages.length).toBe(1);
     });
+
+    it('Should have style data', function () {
+      // Create default Story.
+      const s = new Story();
+      // Add a stylesheet.
+      s.storyStylesheet = 'Test';
+      // Convert to JSON and then back to object.
+      const result = JSON.parse(s.toJSON());
+      // Should have a stylesheet.
+      expect(result.style).toBe('Test');
+    }
+    );
+
+    it('Should have script data', function () {
+      // Create default Story.
+      const s = new Story();
+      // Add a script.
+      s.storyJavaScript = 'Test';
+      // Convert to JSON and then back to object.
+      const result = JSON.parse(s.toJSON());
+      // Should have a script.
+      expect(result.script).toBe('Test');
+    }
+    );
   });
 
   describe('toTwee()', function () {
@@ -647,6 +710,48 @@ describe('Story', () => {
       // Test for passage text.
       expect(p[0].text).toBe('Test');
     });
+
+    it('Should encode story stylesheet as passage with "stylesheet" tag', () => {
+      // Add passages.
+      s.storyStylesheet = 'Test';
+
+      // Set IFID.
+      s.IFID = 'DE7DF8AD-E4CD-499E-A4E7-C5B98B73449A';
+
+      // Convert into Twee.
+      const t = s.toTwee();
+
+      // Convert back into Story.
+      const story = parseTwee(t);
+
+      // Search for 'stylesheet'.
+      const p = story.getPassagesByTag('stylesheet');
+
+      // Test for passage text.
+      expect(p[0].text).toBe('Test');
+    }
+    );
+
+    it('Should encode story JavaScript as passage with "script" tag', () => {
+      // Add passages.
+      s.storyJavaScript = 'Test';
+
+      // Set IFID.
+      s.IFID = 'DE7DF8AD-E4CD-499E-A4E7-C5B98B73449A';
+
+      // Convert into Twee.
+      const t = s.toTwee();
+
+      // Convert back into Story.
+      const story = parseTwee(t);
+
+      // Search for 'stylesheet'.
+      const p = story.getPassagesByTag('script');
+
+      // Test for passage text.
+      expect(p[0].text).toBe('Test');
+    }
+    );
   });
 
   describe('toTwine2HTML()', () => {
@@ -695,6 +800,19 @@ describe('Story', () => {
       expect(result.includes('<style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css">Word')).toBe(true);
     });
 
+    it('Should encode stylesheet property', () => {
+      // Add passage.
+      s.addPassage(new Passage('Start', 'Word'));
+      // Set start.
+      s.start = 'Start';
+      // Set stylesheet.
+      s.storyStylesheet = 'Test';
+      // Create HTML.
+      const result = s.toTwine2HTML();
+      // Expect the stylesheet passage text to be encoded.
+      expect(result.includes('<style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css">Test')).toBe(true);
+    });
+
     it('Should encode script passages', () => {
       // Add passage.
       s.addPassage(new Passage('Start', 'Word'));
@@ -708,6 +826,19 @@ describe('Story', () => {
       expect(result.includes('<script role="script" id="twine-user-script" type="text/twine-javascript">Word')).toBe(true);
     });
 
+    it('Should encode script property', () => {
+      // Add passage.
+      s.addPassage(new Passage('Start', 'Word'));
+      // Set start.
+      s.start = 'Start';
+      // Set script.
+      s.storyJavaScript = 'Test';
+      // Create HTML.
+      const result = s.toTwine2HTML();
+      // Expect the script passage text to be encoded.
+      expect(result.includes('<script role="script" id="twine-user-script" type="text/twine-javascript">Test')).toBe(true);
+    });
+
     it('Should encode format', () => {
       // Add passage.
       s.addPassage(new Passage('Start', 'Word'));

package/test/TWS/Parse.test.js

@@ -7,28 +7,6 @@ describe('TWSParser', () => {
       expect(() => { parseTWS(0); }).toThrow();
     });
 
-    describe('Story parsing', function () {
-      let r = null;
-
-      beforeAll(() => {
-        const contents = fs.readFileSync('test/TWS/TWSParser/Example1.tws');
-        //const b = Buffer.from(contents, 'binary');
-        r = parseTWS(contents);
-      });
-
-      it('Should parse StoryTitle', function () {
-        expect(r.name).toBe('Untitled Story');
-      });
-
-      it('Should parse zoom', function () {
-        expect(r.zoom).toBe(1);
-      });
-
-      it('Should parse start passage', function () {
-        expect(r.start).toBe('Start');
-      });
-    });
-
     describe('Passage parsing', function () {
       let r = null;
 

package/test/Web/window.Extwee.test.js

@@ -0,0 +1,85 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import '../../web-index.js';
+
+describe('Extwee', () => {
+    it('should have all the expected properties', () => {
+        expect(window.Extwee).toHaveProperty('parseTwee');
+        expect(window.Extwee).toHaveProperty('parseJSON');
+        expect(window.Extwee).toHaveProperty('parseTWS');
+        expect(window.Extwee).toHaveProperty('parseStoryFormat');
+        expect(window.Extwee).toHaveProperty('parseTwine1HTML');
+        expect(window.Extwee).toHaveProperty('parseTwine2HTML');
+        expect(window.Extwee).toHaveProperty('parseTwine2ArchiveHTML');
+        expect(window.Extwee).toHaveProperty('compileTwine1HTML');
+        expect(window.Extwee).toHaveProperty('compileTwine2HTML');
+        expect(window.Extwee).toHaveProperty('compileTwine2ArchiveHTML');
+        expect(window.Extwee).toHaveProperty('generateIFID');
+        expect(window.Extwee).toHaveProperty('Story');
+        expect(window.Extwee).toHaveProperty('Passage');
+        expect(window.Extwee).toHaveProperty('StoryFormat');
+    });
+
+    it('should have the expected types', () => {
+        expect(typeof window.Extwee.parseTwee).toBe('function');
+        expect(typeof window.Extwee.parseJSON).toBe('function');
+        expect(typeof window.Extwee.parseTWS).toBe('function');
+        expect(typeof window.Extwee.parseStoryFormat).toBe('function');
+        expect(typeof window.Extwee.parseTwine1HTML).toBe('function');
+        expect(typeof window.Extwee.parseTwine2HTML).toBe('function');
+        expect(typeof window.Extwee.parseTwine2ArchiveHTML).toBe('function');
+        expect(typeof window.Extwee.compileTwine1HTML).toBe('function');
+        expect(typeof window.Extwee.compileTwine2HTML).toBe('function');
+        expect(typeof window.Extwee.compileTwine2ArchiveHTML).toBe('function');
+        expect(typeof window.Extwee.generateIFID).toBe('function');
+        expect(typeof window.Extwee.Story).toBe('function');
+        expect(typeof window.Extwee.Passage).toBe('function');
+        expect(typeof window.Extwee.StoryFormat).toBe('function');
+    });
+
+    it('should have the expected properties in StoryFormat', () => {
+        const storyFormat = new window.Extwee.StoryFormat();
+        expect(storyFormat).toHaveProperty('name');
+        expect(storyFormat).toHaveProperty('version');
+        expect(storyFormat).toHaveProperty('description');
+        expect(storyFormat).toHaveProperty('author');
+        expect(storyFormat).toHaveProperty('image');
+        expect(storyFormat).toHaveProperty('url');
+        expect(storyFormat).toHaveProperty('license');
+        expect(storyFormat).toHaveProperty('proofing');
+        expect(storyFormat).toHaveProperty('source');
+    });
+
+    it('should have the expected properties in Story', () => {
+        const story = new window.Extwee.Story();
+        expect(story).toHaveProperty('name');
+        expect(story).toHaveProperty('IFID');
+        expect(story).toHaveProperty('start');
+        expect(story).toHaveProperty('format');
+        expect(story).toHaveProperty('formatVersion');
+        expect(story).toHaveProperty('zoom');
+        expect(story).toHaveProperty('passages');
+        expect(story).toHaveProperty('creator');
+        expect(story).toHaveProperty('creatorVersion');
+        expect(story).toHaveProperty('metadata');
+        expect(story).toHaveProperty('tagColors');
+        expect(story).toHaveProperty('storyJavaScript');
+        expect(story).toHaveProperty('storyStylesheet');
+    });
+   
+    it('should have the expected types in Passage', () => {
+        const passage = new window.Extwee.Passage();
+        expect(passage).toHaveProperty('name');
+        expect(passage).toHaveProperty('text');
+        expect(passage).toHaveProperty('tags');
+        expect(passage).toHaveProperty('metadata');
+    });
+
+    it('should generate a valid IFID', () => {
+        const ifid = window.Extwee.generateIFID();
+        expect(ifid).toMatch(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/);
+    });
+
+});

package/types/Story.d.ts

@@ -13,6 +13,8 @@
  * @property {string} creatorVersion - Version used to create Story.
  * @property {object} metadata - Metadata of Story.
  * @property {object} tagColors - Tag Colors
+ * @property {string} storyJavaScript - Story JavaScript
+ * @property {string} storyStylesheet - Story Stylesheet
  * @method {number} addPassage - Add a passage to the story and returns the new length of the passages array.
  * @method {number} removePassageByName - Remove a passage from the story by name and returns the new length of the passages array.
  * @method {Array} getPassagesByTag - Find passages by tag.
@@ -142,6 +144,25 @@ export class Story {
      * @property {Array} passages - Passages
     */
     get passages(): any[];
+    /**
+     * @param {string} s - Replacement story stylesheet
+     */
+    set storyStylesheet(s: string);
+    /**
+     * Story stylesheet data can be set as a passage, property value, or both.
+     * @returns {string} storyStylesheet
+     */
+    get storyStylesheet(): string;
+    /**
+     * Set story JavaScript.
+     * @param {string} s - Replacement story JavaScript
+     */
+    set storyJavaScript(s: string);
+    /**
+     * Get story JavaScript.
+     * @returns {string} storyJavaScript
+     */
+    get storyJavaScript(): string;
     /**
      * Add a passage to the story.
      * Passing `StoryData` will override story metadata and `StoryTitle` will override story name.
@@ -209,6 +230,10 @@ export class Story {
      * - `format`: (string) Optional. The format of the story.
      * - `format-version`: (string) Optional. The version of the format of the story.
      *
+     * Because story stylesheet data can be represented as a passage, property value, or both, all approaches are encoded.
+     *
+     * Because story JavaScript can be represented as a passage, property value, or both, all approaches are encoded.
+     *
      * @method toTwine2HTML
      * @returns {string} Twine 2 HTML string
      */

package/types/index.d.ts

@@ -8,7 +8,9 @@ import { parse as parseTwine2ArchiveHTML } from './src/Twine2ArchiveHTML/parse.j
 import { compile as compileTwine1HTML } from './src/Twine1HTML/compile.js';
 import { compile as compileTwine2HTML } from './src/Twine2HTML/compile.js';
 import { compile as compileTwine2ArchiveHTML } from './src/Twine2ArchiveHTML/compile.js';
-import Story from './src/Story.js';
+import { compile as compileStoryFormat } from './src/StoryFormat/compile.js';
+import { generate as generateIFID } from './src/IFID/generate.js';
+import { Story } from './src/Story.js';
 import Passage from './src/Passage.js';
 import StoryFormat from './src/StoryFormat.js';
-export { parseTwee, parseJSON, parseTWS, parseStoryFormat, parseTwine1HTML, parseTwine2HTML, parseTwine2ArchiveHTML, compileTwine1HTML, compileTwine2HTML, compileTwine2ArchiveHTML, Story, Passage, StoryFormat };
+export { parseTwee, parseJSON, parseTWS, parseStoryFormat, parseTwine1HTML, parseTwine2HTML, parseTwine2ArchiveHTML, compileTwine1HTML, compileTwine2HTML, compileTwine2ArchiveHTML, compileStoryFormat, generateIFID, Story, Passage, StoryFormat };

package/types/src/CLI/CommandLineProcessing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Process command line arguments.
+ * @function CommandLineProcessing
+ * @description This function processes the command line arguments passed to the Extwee CLI.
+ * @module CLI/commandLineProcessing
+ * @param {Array} argv - The command line arguments passed to the CLI.
+ */
+export function CommandLineProcessing(argv: any[]): void;

package/types/src/CLI/ProcessConfig/loadStoryFormat.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Load the story format from the story-formats directory.
+ * @function loadStoryFormat
+ * @description This function loads the story format from the story-formats directory.
+ * It checks if the story-formats directory exists, if the named story format exists,
+ * if the version directory exists, and if the format.js file exists.
+ * If any of these checks fail, the function will exit the process with an error message.
+ * If all checks pass, the function will return the contents of the format.js file.
+ * @param {string} storyFormatName - The name of the story format.
+ * @param {string} storyFormatVersion - The version of the story format.
+ * @returns {string} - The contents of the format.js file.
+ * @throws {Error} - If the story-formats directory does not exist, if the named story format does not exist,
+ * if the version directory does not exist, or if the format.js file does not exist.
+ * @example
+ * // Load the story format from the story-formats directory.
+ * const storyFormat = loadStoryFormat('Harlowe', '3.2.0');
+ * console.log(storyFormat);
+ * // Output: The contents of the format.js file.
+ */
+export function loadStoryFormat(storyFormatName: string, storyFormatVersion: string): string;

package/types/src/CLI/ProcessConfig/readDirectories.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read the contents of a directory and returns all directories.
+ * @function readDirectories
+ * @description This function reads the contents of a directory and returns a list of directories.
+ * @param {string} directory - The path to the directory to read.
+ * @returns {Array<string>} - An array of directories in the directory.
+ * @throws {Error} - If the directory does not exist or if there is an error reading the directory.
+ */
+export function readDirectories(directory: string): Array<string>;

package/types/src/CLI/ProcessConfig.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Processes the config file, if present.
+ * @function ConfigFileProcessing
+ * @description This function processes the config file.
+ * It checks if the config file exists and if it does, it reads the config file.
+ * If the config file does not exist, the function will exit the process with an error message.
+ * The config file is used to store configuration options for the Extwee CLI.
+ * @returns {void}
+ * @throws {Error} - If the config file does not exist or if there is an error parsing the config file.
+ */
+export function ConfigFileProcessing(): void;
+export function ConfigFilePresent(): boolean;

package/types/src/CLI/isDirectory.d.ts

@@ -0,0 +1 @@
+export function isDirectory(path: any): boolean;

package/types/src/CLI/isFile.d.ts

@@ -0,0 +1 @@
+export function isFile(path: any): boolean;

package/types/src/Config/parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parses a JSON object and extracts the StoryFormat, StoryTitle and StoryVersion.
+ * @param {object} obj Incoming JSON object.
+ * @returns {object} An object containing the extracted results.
+ */
+export function parser(obj: object): object;

package/types/src/Config/reader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read a JSON file and return its contents.
+ * @param {string} path Path to the JSON file.
+ * @returns {object} Parsed JSON object.
+ * @throws {Error} If the file does not exist.
+ * @throws {Error} If the file is not a valid JSON file.
+ * @example
+ * const contents = reader('test/Config/files/valid.json');
+ * console.log(contents); // {"story-format": 'Harlowe', "story-title": "My Story"}
+ */
+export function reader(path: string): object;

package/types/src/IFID/generate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates an Interactive Fiction Identification (IFID) based the Treaty of Babel.
+ *
+ * For Twine works, the IFID is a UUID (v4) in uppercase.
+ * @see Treaty of Babel ({@link https://babel.ifarchive.org/babel_rev11.html#the-ifid-for-an-html-story-file})
+ * @function generate
+ * @description Generates a new IFID.
+ * @returns {string} IFID
+ * @example
+ * const ifid = generate();
+ * console.log(ifid);
+ * // => 'A1B2C3D4-E5F6-G7H8-I9J0-K1L2M3N4O5P6'
+ */
+export function generate(): string;