text-runner-engine 7.1.0

package/dist/filesystem/full-file.d.ts

@@ -0,0 +1,22 @@
+import * as files from "./index.js";
+/**
+ * represents a full path to a file,
+ * i.e. a path from the document base to a file.
+ */
+export declare class FullFilePath {
+    private value;
+    constructor(value: string);
+    /** Returns the directory that contains this file */
+    directory(): files.FullPath;
+    /** Returns the file extension of this path */
+    extName(): string;
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified(): string;
+    toFullFilePath(): FullFilePath;
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified(): string;
+}
+//# sourceMappingURL=full-file.d.ts.map

package/dist/filesystem/full-file.js

@@ -0,0 +1,35 @@
+import * as path from "path";
+import * as files from "./index.js";
+const sepRE = new RegExp("\\" + path.sep, "g");
+/**
+ * represents a full path to a file,
+ * i.e. a path from the document base to a file.
+ */
+export class FullFilePath {
+    constructor(value) {
+        this.value = value.replace(sepRE, "/");
+    }
+    /** Returns the directory that contains this file */
+    directory() {
+        return new files.FullPath(path.dirname(this.value) + "/");
+    }
+    /** Returns the file extension of this path */
+    extName() {
+        return path.extname(this.value);
+    }
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified() {
+        return this.value.replace(/\//g, path.sep);
+    }
+    toFullFilePath() {
+        return this;
+    }
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified() {
+        return this.value;
+    }
+}
+//# sourceMappingURL=full-file.js.map

package/dist/filesystem/full-link.d.ts

@@ -0,0 +1,40 @@
+import * as configuration from "../configuration/index.js";
+import * as files from "./index.js";
+/**
+ * Represents a link to another Markdown file,
+ * all the way from the root directory
+ * (i.e. a link starting with '/')
+ */
+export declare class FullLink {
+    readonly value: string;
+    constructor(publicPath: string);
+    /** Returns the anchor part of this link */
+    anchor(): string;
+    /**
+     * Returns a new link that consists of this link
+     * with the given relative link appended
+     */
+    append(segment: files.RelativeLink): FullLink;
+    /** Returns a link to the containing directory */
+    directory(): FullLink;
+    hasAnchor(): boolean;
+    /** Returns whether this link has the given extension */
+    hasExtension(extension: string): boolean;
+    /** Returns whether this link points to a directory */
+    isLinkToDirectory(): boolean;
+    /** Returns the file path that this link has on the local filesystem */
+    localize(publications: configuration.Publications, defaultFile: string): files.FullFilePath | files.FullPath;
+    /**
+     * Returns a link where the old enclosing directory is replaced
+     * with the new enclosing directory
+     */
+    rebase(oldPath: string, newPath: string): FullLink;
+    urlDecoded(): FullLink;
+    /** Returns a link that contains the given anchor */
+    withAnchor(anchor: string): FullLink;
+    /** Returns another FullLink instance that uses the given file extension */
+    withExtension(newExtension: string): FullLink;
+    /** Returns a link that is this link without the anchor */
+    withoutAnchor(): FullLink;
+}
+//# sourceMappingURL=full-link.d.ts.map

package/dist/filesystem/full-link.js

@@ -0,0 +1,80 @@
+import * as path from "path";
+import * as helpers from "../helpers/index.js";
+import * as files from "./index.js";
+/**
+ * Represents a link to another Markdown file,
+ * all the way from the root directory
+ * (i.e. a link starting with '/')
+ */
+export class FullLink {
+    constructor(publicPath) {
+        this.value = helpers.addLeadingSlash(helpers.removeDoubleSlash(helpers.unixify(publicPath)));
+    }
+    /** Returns the anchor part of this link */
+    anchor() {
+        return this.value.split("#")[1] || "";
+    }
+    /**
+     * Returns a new link that consists of this link
+     * with the given relative link appended
+     */
+    append(segment) {
+        return new FullLink(helpers.straightenLink(this.value + "/" + segment.value));
+    }
+    /** Returns a link to the containing directory */
+    directory() {
+        const withoutAnchor = this.withoutAnchor();
+        if (withoutAnchor.isLinkToDirectory()) {
+            return withoutAnchor;
+        }
+        return new FullLink(withoutAnchor.value.substr(0, withoutAnchor.value.lastIndexOf("/") + 1));
+    }
+    hasAnchor() {
+        return this.anchor() !== "";
+    }
+    /** Returns whether this link has the given extension */
+    hasExtension(extension) {
+        return path.extname(this.value) === helpers.addLeadingDotUnlessEmpty(extension);
+    }
+    /** Returns whether this link points to a directory */
+    isLinkToDirectory() {
+        return this.value.endsWith("/");
+    }
+    /** Returns the file path that this link has on the local filesystem */
+    localize(publications, defaultFile) {
+        const publication = publications.publicationForLink(this);
+        const result = publication
+            ? publication.resolve(this.urlDecoded(), defaultFile)
+            : new files.FullPath(this.urlDecoded().withoutAnchor().value);
+        // append the default file
+        if (result.extName() === "" && defaultFile) {
+            return result.append(defaultFile);
+        }
+        return result;
+    }
+    /**
+     * Returns a link where the old enclosing directory is replaced
+     * with the new enclosing directory
+     */
+    rebase(oldPath, newPath) {
+        const re = new RegExp("^" + oldPath);
+        return new FullLink(this.value.replace(re, newPath));
+    }
+    urlDecoded() {
+        return new FullLink(decodeURI(this.value));
+    }
+    /** Returns a link that contains the given anchor */
+    withAnchor(anchor) {
+        return new FullLink(this.withoutAnchor().value + "#" + anchor);
+    }
+    /** Returns another FullLink instance that uses the given file extension */
+    withExtension(newExtension) {
+        const extRE = new RegExp(path.extname(this.value) + "$");
+        return new FullLink(this.value.replace(extRE, helpers.addLeadingDotUnlessEmpty(newExtension)));
+    }
+    /** Returns a link that is this link without the anchor */
+    withoutAnchor() {
+        return new FullLink(this.value.split("#")[0]);
+    }
+}
+//# sourceMappingURL=full-link.js.map

package/dist/filesystem/full-path.d.ts

@@ -0,0 +1,31 @@
+import * as configuration from "../configuration/index.js";
+import * as files from "./index.js";
+/**
+ * represents a full path to either a file or a directory,
+ * i.e. a link from the document base root to the object
+ */
+export declare class FullPath {
+    private readonly value;
+    constructor(value: string);
+    /** Returns a new file path with the given file name appended to the end of this file path */
+    append(fileName: string): files.FullFilePath;
+    /** Returns the directory that contains this file path */
+    directory(): FullPath;
+    /** Returns the file extension of this path */
+    extName(): string;
+    /** Returns whether this file path points to a directory */
+    isDirectory(): boolean;
+    joinStr(relPath: string): string;
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified(): string;
+    /** Returns the public link under which this file path is published */
+    publicPath(publications: configuration.Publications): files.FullLink;
+    /** provides the FullFilePath if this path points to a file */
+    toFullFilePath(): files.FullFilePath;
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified(): string;
+}
+//# sourceMappingURL=full-path.d.ts.map

package/dist/filesystem/full-path.js

@@ -0,0 +1,61 @@
+import * as path from "path";
+import * as helpers from "../helpers/index.js";
+import * as files from "./index.js";
+/**
+ * represents a full path to either a file or a directory,
+ * i.e. a link from the document base root to the object
+ */
+export class FullPath {
+    constructor(value) {
+        this.value = helpers.removeLeadingSlash(helpers.unixify(value));
+    }
+    /** Returns a new file path with the given file name appended to the end of this file path */
+    append(fileName) {
+        return new files.FullFilePath(path.join(this.platformified(), fileName));
+    }
+    /** Returns the directory that contains this file path */
+    directory() {
+        if (this.isDirectory()) {
+            return this;
+        }
+        return new FullPath(path.dirname(this.value) + "/");
+    }
+    /** Returns the file extension of this path */
+    extName() {
+        return path.extname(this.value);
+    }
+    /** Returns whether this file path points to a directory */
+    isDirectory() {
+        return this.value.endsWith("/");
+    }
+    joinStr(relPath) {
+        return path.join(this.value, relPath);
+    }
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified() {
+        return this.value.replace(/\//g, path.sep);
+    }
+    /** Returns the public link under which this file path is published */
+    publicPath(publications) {
+        const publication = publications.forFilePath(this);
+        if (publication == null) {
+            return new files.FullLink(this.unixified());
+        }
+        return publication.publish(this);
+    }
+    /** provides the FullFilePath if this path points to a file */
+    toFullFilePath() {
+        if (this.isDirectory()) {
+            throw new Error(`FullPath '${this.unixified()}' does tot point to a file`);
+        }
+        return new files.FullFilePath(this.value);
+    }
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified() {
+        return this.value;
+    }
+}
+//# sourceMappingURL=full-path.js.map

package/dist/filesystem/get-filenames.d.ts

@@ -0,0 +1,15 @@
+import * as configuration from "../configuration/index.js";
+import * as files from "./index.js";
+/**
+ * Returns the FullPaths of all files/directories relative to the given sourceDir
+ * that match the given glob
+ */
+export declare function getFileNames(config: configuration.Data): Promise<files.FullFilePath[]>;
+/**
+ * returns all the markdown files in this directory and its children,
+ * relative to the given sourceDir
+ */
+export declare function markdownFilesInDir(dirName: string, sourceDir: files.SourceDir): Promise<files.FullFilePath[]>;
+/** Removes the given excluded files from the given list of filenames */
+export declare function removeExcludedFiles(fileList: files.FullFilePath[], excluded: string | string[]): files.FullFilePath[];
+//# sourceMappingURL=get-filenames.d.ts.map

package/dist/filesystem/get-filenames.js

@@ -0,0 +1,73 @@
+import { globby } from "globby";
+import isGlob from "is-glob";
+import { UserError } from "../errors/user-error.js";
+import * as files from "./index.js";
+/**
+ * Returns the FullPaths of all files/directories relative to the given sourceDir
+ * that match the given glob
+ */
+export async function getFileNames(config) {
+    let filenames = await getFiles(config);
+    filenames = removeExcludedFiles(filenames, config.exclude);
+    filenames = removeExcludedFiles(filenames, "node_modules");
+    if (config.emptyWorkspace === false) {
+        if (!config.workspace.matches(config.sourceDir)) {
+            const fullWorkspace = config.workspace.toFullDir(config.sourceDir);
+            filenames = removeExcludedFiles(filenames, fullWorkspace.platformified());
+        }
+    }
+    return filenames;
+}
+/**
+ * returns all the markdown files in this directory and its children,
+ * relative to the given sourceDir
+ */
+export async function markdownFilesInDir(dirName, sourceDir) {
+    const allFiles = await globby(`${dirName}/**/*.md`);
+    return allFiles
+        .filter(file => !file.includes("node_modules"))
+        .sort()
+        .map(file => new files.AbsoluteFilePath(file).toFullFile(sourceDir));
+}
+/** Removes the given excluded files from the given list of filenames */
+export function removeExcludedFiles(fileList, excluded) {
+    const excludedFilesArray = Array.isArray(excluded) ? excluded : [excluded];
+    const excludedRegexes = excludedFilesArray.map(file => new RegExp(file));
+    return fileList.filter(file => {
+        for (const excludedRegex of excludedRegexes) {
+            if (excludedRegex.test(file.unixified())) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Returns files described by the given configuration.
+ * Filenames are relative to config.sourceDir.
+ */
+async function getFiles(config) {
+    let fullGlob = config.sourceDir.joinStr(config.files);
+    if (process.platform === "win32") {
+        // globby cannot handle backslashes in globs,
+        // see https://github.com/sindresorhus/globby/issues/155#issuecomment-732961466
+        // and https://github.com/micromatch/micromatch#backslashes
+        fullGlob = fullGlob.replace(/\\/g, "/");
+    }
+    if (config.files === "") {
+        return markdownFilesInDir("", config.sourceDir);
+    }
+    else if (await files.hasDirectory(fullGlob)) {
+        return markdownFilesInDir(fullGlob, config.sourceDir);
+    }
+    else if (await files.isMarkdownFile(fullGlob)) {
+        return [new files.FullFilePath(config.files)];
+    }
+    else if (isGlob(config.files)) {
+        return config.sourceDir.fullFilesMatchingGlob(fullGlob);
+    }
+    else {
+        throw new UserError(`file or directory does not exist: ${config.files}`, "You can provide a glob expression or the path to a file or folder.");
+    }
+}
+//# sourceMappingURL=get-filenames.js.map

package/dist/filesystem/has-directory.d.ts

@@ -0,0 +1,2 @@
+export declare function hasDirectory(dirname: string): Promise<boolean>;
+//# sourceMappingURL=has-directory.d.ts.map

package/dist/filesystem/has-directory.js

@@ -0,0 +1,11 @@
+import { promises as fs } from "fs";
+export async function hasDirectory(dirname) {
+    try {
+        const stats = await fs.stat(dirname);
+        return stats.isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=has-directory.js.map

package/dist/filesystem/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./absolute-dir.js";
+export * from "./absolute-file.js";
+export * from "./full-dir.js";
+export * from "./full-file.js";
+export * from "./full-link.js";
+export * from "./full-path.js";
+export * from "./get-filenames.js";
+export * from "./has-directory.js";
+export * from "./is-markdown-file.js";
+export * from "./location.js";
+export * from "./relative-dir.js";
+export * from "./relative-link.js";
+export * from "./source-dir.js";
+export * from "./unknown-link.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/filesystem/index.js

@@ -0,0 +1,15 @@
+export * from "./absolute-dir.js";
+export * from "./absolute-file.js";
+export * from "./full-dir.js";
+export * from "./full-file.js";
+export * from "./full-link.js";
+export * from "./full-path.js";
+export * from "./get-filenames.js";
+export * from "./has-directory.js";
+export * from "./is-markdown-file.js";
+export * from "./location.js";
+export * from "./relative-dir.js";
+export * from "./relative-link.js";
+export * from "./source-dir.js";
+export * from "./unknown-link.js";
+//# sourceMappingURL=index.js.map

package/dist/filesystem/is-markdown-file.d.ts

@@ -0,0 +1,2 @@
+export declare function isMarkdownFile(filepath: string): Promise<boolean>;
+//# sourceMappingURL=is-markdown-file.d.ts.map

package/dist/filesystem/is-markdown-file.js

@@ -0,0 +1,11 @@
+import { promises as fs } from "fs";
+export async function isMarkdownFile(filepath) {
+    try {
+        const fileStats = await fs.stat(filepath);
+        return filepath.endsWith(".md") && fileStats.isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=is-markdown-file.js.map

package/dist/filesystem/location.d.ts

@@ -0,0 +1,17 @@
+import * as files from "./index.js";
+/** represents a location inside the document base, i.e. a line inside a file */
+export declare class Location {
+    file: files.FullFilePath;
+    line: number;
+    sourceDir: files.SourceDir;
+    constructor(sourceDir: files.SourceDir, file: files.FullFilePath, line: number);
+    /** provides an empty location for testing */
+    static scaffold(): Location;
+    /** provides the absolute path to the file in this location */
+    absoluteFilePath(): files.AbsoluteFilePath;
+    /** provides a copy of this Location with the given file */
+    withFile(file: files.FullFilePath): Location;
+    /** provides a copy of this Location with the given line */
+    withLine(line: number): Location;
+}
+//# sourceMappingURL=location.d.ts.map

package/dist/filesystem/location.js

@@ -0,0 +1,26 @@
+import * as files from "./index.js";
+/** represents a location inside the document base, i.e. a line inside a file */
+export class Location {
+    constructor(sourceDir, file, line) {
+        this.sourceDir = sourceDir;
+        this.file = file;
+        this.line = line;
+    }
+    /** provides an empty location for testing */
+    static scaffold() {
+        return new Location(new files.SourceDir(""), new files.FullFilePath(""), 0);
+    }
+    /** provides the absolute path to the file in this location */
+    absoluteFilePath() {
+        return this.sourceDir.joinFullFile(this.file);
+    }
+    /** provides a copy of this Location with the given file */
+    withFile(file) {
+        return new Location(this.sourceDir, file, this.line);
+    }
+    /** provides a copy of this Location with the given line */
+    withLine(line) {
+        return new Location(this.sourceDir, this.file, line);
+    }
+}
+//# sourceMappingURL=location.js.map

package/dist/filesystem/relative-dir.d.ts

@@ -0,0 +1,6 @@
+/** represents a relative path to another directory */
+export declare class RelativeDir {
+    value: string;
+    constructor(value: string);
+}
+//# sourceMappingURL=relative-dir.d.ts.map

package/dist/filesystem/relative-dir.js

@@ -0,0 +1,7 @@
+/** represents a relative path to another directory */
+export class RelativeDir {
+    constructor(value) {
+        this.value = value;
+    }
+}
+//# sourceMappingURL=relative-dir.js.map

package/dist/filesystem/relative-link.d.ts

@@ -0,0 +1,16 @@
+import * as configuration from "../configuration/index.js";
+import * as files from "./index.js";
+/**
+ * A link relative to the current location,
+ * i.e. a link not starting with '/'
+ */
+export declare class RelativeLink {
+    readonly value: string;
+    constructor(publicPath: string);
+    /**
+     * Assuming this relative link is in the given file,
+     * returns the absolute links that point to the same target as this relative link.
+     */
+    absolutify(containingLocation: files.Location, publications: configuration.Publications): files.FullLink;
+}
+//# sourceMappingURL=relative-link.d.ts.map

package/dist/filesystem/relative-link.js

@@ -0,0 +1,18 @@
+/**
+ * A link relative to the current location,
+ * i.e. a link not starting with '/'
+ */
+export class RelativeLink {
+    constructor(publicPath) {
+        this.value = publicPath;
+    }
+    /**
+     * Assuming this relative link is in the given file,
+     * returns the absolute links that point to the same target as this relative link.
+     */
+    absolutify(containingLocation, publications) {
+        const urlOfDir = containingLocation.file.directory().publicPath(publications);
+        return urlOfDir.append(this);
+    }
+}
+//# sourceMappingURL=relative-link.js.map

package/dist/filesystem/source-dir.d.ts

@@ -0,0 +1,19 @@
+import * as files from "./index.js";
+/** represents the document base directory */
+export declare class SourceDir {
+    value: string;
+    constructor(value: string);
+    fullFilesMatchingGlob(expression: string): Promise<files.FullFilePath[]>;
+    joinFullDir(dir: files.FullDir): files.AbsoluteDirPath;
+    joinFullFile(file: files.FullFilePath): files.AbsoluteFilePath;
+    /** provides a path of this directory with the given path appended */
+    joinStr(...paths: string[]): string;
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified(): string;
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified(): string;
+}
+//# sourceMappingURL=source-dir.d.ts.map

package/dist/filesystem/source-dir.js

@@ -0,0 +1,35 @@
+import { globby } from "globby";
+import * as path from "path";
+import * as files from "./index.js";
+/** represents the document base directory */
+export class SourceDir {
+    constructor(value) {
+        this.value = value;
+    }
+    async fullFilesMatchingGlob(expression) {
+        const allFiles = await globby(expression);
+        return allFiles.sort().map(file => new files.AbsoluteFilePath(file).toFullFile(this));
+    }
+    joinFullDir(dir) {
+        return new files.AbsoluteDirPath(path.join(this.platformified(), dir.platformified()));
+    }
+    joinFullFile(file) {
+        return new files.AbsoluteFilePath(path.join(this.platformified(), file.platformified()));
+    }
+    /** provides a path of this directory with the given path appended */
+    joinStr(...paths) {
+        return path.join(this.platformified(), ...paths);
+    }
+    /**
+     * Returns the path in the platform-specific format,
+     * i.e. using '\' on Windows and '/' everywhere else
+     */
+    platformified() {
+        return this.value.replace(/\//g, path.sep);
+    }
+    /** Returns this absolute path using forward slashes as path separators */
+    unixified() {
+        return this.value;
+    }
+}
+//# sourceMappingURL=source-dir.js.map

package/dist/filesystem/unknown-link.d.ts

@@ -0,0 +1,15 @@
+import * as configuration from "../configuration/index.js";
+import * as files from "./index.js";
+/**
+ * A link that isn't known yet whether it is relative or absolute
+ */
+export declare class UnknownLink {
+    private readonly value;
+    constructor(publicPath: string);
+    absolutify(containingLocation: files.Location, publications: configuration.Publications): files.FullLink;
+    /**
+     * Returns whether this link is an absolute link
+     */
+    isAbsolute(): boolean;
+}
+//# sourceMappingURL=unknown-link.d.ts.map

package/dist/filesystem/unknown-link.js

@@ -0,0 +1,23 @@
+import * as helpers from "../helpers/index.js";
+import * as files from "./index.js";
+/**
+ * A link that isn't known yet whether it is relative or absolute
+ */
+export class UnknownLink {
+    constructor(publicPath) {
+        this.value = helpers.removeDoubleSlash(helpers.unixify(publicPath));
+    }
+    absolutify(containingLocation, publications) {
+        if (this.isAbsolute()) {
+            return new files.FullLink(this.value);
+        }
+        return new files.RelativeLink(this.value).absolutify(containingLocation, publications);
+    }
+    /**
+     * Returns whether this link is an absolute link
+     */
+    isAbsolute() {
+        return this.value.startsWith("/");
+    }
+}
+//# sourceMappingURL=unknown-link.js.map

package/dist/helpers/add-leading-dot-unless-empty.d.ts

@@ -0,0 +1,2 @@
+export declare function addLeadingDotUnlessEmpty(text: string): string;
+//# sourceMappingURL=add-leading-dot-unless-empty.d.ts.map

package/dist/helpers/add-leading-dot-unless-empty.js

@@ -0,0 +1,10 @@
+export function addLeadingDotUnlessEmpty(text) {
+    if (text === "") {
+        return text;
+    }
+    if (text.startsWith(".")) {
+        return text;
+    }
+    return "." + text;
+}
+//# sourceMappingURL=add-leading-dot-unless-empty.js.map

package/dist/helpers/add-leading-slash.d.ts

@@ -0,0 +1,2 @@
+export declare function addLeadingSlash(filepath: string): string;
+//# sourceMappingURL=add-leading-slash.d.ts.map

package/dist/helpers/add-leading-slash.js

@@ -0,0 +1,9 @@
+export function addLeadingSlash(filepath) {
+    if (filepath[0] === "/") {
+        return filepath;
+    }
+    else {
+        return "/" + filepath;
+    }
+}
+//# sourceMappingURL=add-leading-slash.js.map

package/dist/helpers/add-trailing-slash.d.ts

@@ -0,0 +1,2 @@
+export declare function addTrailingSlash(text: string): string;
+//# sourceMappingURL=add-trailing-slash.d.ts.map