@knight-lab/timelinejs 3.9.6 → 3.9.7

package/eleventy/node_modules/@11ty/eleventy/src/Util/HtmlTransformer.js

@@ -0,0 +1,158 @@
+import posthtml from "posthtml";
+import urls from "@11ty/posthtml-urls";
+import { FilePathUtil } from "./FilePathUtil.js";
+
+class HtmlTransformer {
+	// feature test for Eleventy Bundle Plugin
+	static SUPPORTS_PLUGINS_ENABLED_CALLBACK = true;
+
+	constructor() {
+		// execution order is important (not order of addition/object key order)
+		this.callbacks = {};
+		this.posthtmlProcessOptions = {};
+		this.plugins = {};
+	}
+
+	get aggregateBench() {
+		if (!this.userConfig) {
+			throw new Error("Internal error: Missing `userConfig` in HtmlTransformer.");
+		}
+		return this.userConfig.benchmarkManager.get("Aggregate");
+	}
+
+	setUserConfig(config) {
+		this.userConfig = config;
+	}
+
+	static prioritySort(a, b) {
+		if (b.priority > a.priority) {
+			return 1;
+		}
+		if (a.priority > b.priority) {
+			return -1;
+		}
+		return 0;
+	}
+
+	// context is important as it is used in html base plugin for page specific URL
+	static _getPosthtmlInstance(callbacks = [], plugins = [], context = {}) {
+		let inst = posthtml();
+
+		// already sorted by priority when added
+		for (let { fn: plugin, options } of plugins) {
+			inst.use(plugin(Object.assign({}, context, options)));
+		}
+
+		// Run the built-ins last
+		if (callbacks.length > 0) {
+			inst.use(
+				urls({
+					eachURL: (url) => {
+						// and: attrName, tagName
+						for (let { fn: callback } of callbacks) {
+							// already sorted by priority when added
+							url = callback.call(context, url);
+						}
+
+						return url;
+					},
+				}),
+			);
+		}
+
+		return inst;
+	}
+
+	_add(extensions, addType, value, options = {}) {
+		options = Object.assign(
+			{
+				priority: 0,
+			},
+			options,
+		);
+
+		let extensionsArray = (extensions || "").split(",");
+		for (let ext of extensionsArray) {
+			let target = this[addType];
+			if (!target[ext]) {
+				target[ext] = [];
+			}
+
+			target[ext].push({
+				fn: value, // callback or plugin
+				priority: options.priority,
+				enabled: options.enabled || (() => true),
+				options: options.pluginOptions,
+			});
+
+			target[ext].sort(HtmlTransformer.prioritySort);
+		}
+	}
+
+	addPosthtmlPlugin(extensions, plugin, options = {}) {
+		this._add(extensions, "plugins", plugin, options);
+	}
+
+	addUrlTransform(extensions, callback, options = {}) {
+		this._add(extensions, "callbacks", callback, options);
+	}
+
+	setPosthtmlProcessOptions(options) {
+		Object.assign(this.posthtmlProcessOptions, options);
+	}
+
+	isTransformable(extension, context) {
+		return (
+			this.getCallbacks(extension, context).length > 0 || this.getPlugins(extension).length > 0
+		);
+	}
+
+	getCallbacks(extension, context) {
+		let callbacks = this.callbacks[extension] || [];
+		return callbacks.filter(({ enabled }) => {
+			if (!enabled || typeof enabled !== "function") {
+				return true;
+			}
+			return enabled(context);
+		});
+	}
+
+	getPlugins(extension) {
+		let plugins = this.plugins[extension] || [];
+		return plugins.filter(({ enabled }) => {
+			if (!enabled || typeof enabled !== "function") {
+				return true;
+			}
+			return enabled();
+		});
+	}
+
+	static async transformStandalone(content, callback, posthtmlProcessOptions = {}) {
+		let posthtmlInstance = this._getPosthtmlInstance([
+			{
+				fn: callback,
+				enabled: () => true,
+			},
+		]);
+		let result = await posthtmlInstance.process(content, posthtmlProcessOptions);
+		return result.html;
+	}
+
+	async transformContent(outputPath, content, context) {
+		let extension = FilePathUtil.getFileExtension(outputPath);
+		if (!this.isTransformable(extension, context)) {
+			return content;
+		}
+
+		let bench = this.aggregateBench.get(`Transforming \`${extension}\` with posthtml`);
+		bench.before();
+		let callbacks = this.getCallbacks(extension, context);
+		let plugins = this.getPlugins(extension);
+		let posthtmlInstance = HtmlTransformer._getPosthtmlInstance(callbacks, plugins, context);
+		let result = await posthtmlInstance.process(content, this.posthtmlProcessOptions);
+		bench.after();
+		return result.html;
+	}
+}
+
+export { HtmlTransformer };

package/eleventy/node_modules/@11ty/eleventy/src/Util/ImportJsonSync.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import debugUtil from "debug";
+
+import { TemplatePath } from "@11ty/eleventy-utils";
+
+import { normalizeFilePathInEleventyPackage } from "./Require.js";
+
+const debug = debugUtil("Eleventy:ImportJsonSync");
+const require = createRequire(import.meta.url);
+
+function findFilePathInParentDirs(dir, filename) {
+	// `package.json` searches look in parent dirs:
+	// https://docs.npmjs.com/cli/v7/configuring-npm/folders#more-information
+	// Fixes issue #3178, limited to working dir paths only
+	let workingDir = TemplatePath.getWorkingDir();
+	let allDirs = TemplatePath.getAllDirs(dir).filter((entry) => entry.startsWith(workingDir));
+
+	for (let dir of allDirs) {
+		let newPath = TemplatePath.join(dir, filename);
+		if (fs.existsSync(newPath)) {
+			debug("Found %o searching parent directories at: %o", filename, dir);
+			return newPath;
+		}
+	}
+}
+
+function importJsonSync(filePath) {
+	if (!filePath.endsWith(".json")) {
+		throw new Error(`importJsonSync expects a .json file extension (received: ${filePath})`);
+	}
+
+	try {
+		// TODO clear require.cache when these files change
+		return require(filePath);
+	} catch (e) {
+		debug("Attempted to import %o, received this error: %o", filePath, e);
+		// if file does not exist, return nothing
+	}
+}
+
+function getEleventyPackageJson() {
+	let filePath = normalizeFilePathInEleventyPackage("package.json");
+	return importJsonSync(filePath);
+}
+
+function getModulePackageJson(dir) {
+	let filePath = findFilePathInParentDirs(TemplatePath.absolutePath(dir), "package.json");
+	return importJsonSync(filePath);
+}
+
+function getWorkingProjectPackageJson() {
+	let dir = TemplatePath.absolutePath(TemplatePath.getWorkingDir());
+	let filePath = findFilePathInParentDirs(dir, "package.json");
+	return importJsonSync(filePath);
+}
+
+export {
+	importJsonSync,
+	findFilePathInParentDirs,
+	getEleventyPackageJson,
+	getModulePackageJson,
+	getWorkingProjectPackageJson,
+};

package/eleventy/node_modules/@11ty/eleventy/src/Util/IsAsyncFunction.js

@@ -0,0 +1,5 @@
+const ComparisonAsyncFunction = (async () => {}).constructor;
+
+export default function isAsyncFunction(fn) {
+	return fn instanceof ComparisonAsyncFunction;
+}

package/eleventy/node_modules/@11ty/eleventy/src/Util/JavaScriptDependencies.js

@@ -0,0 +1,55 @@
+import dependencyTree from "@11ty/dependency-tree";
+import { find } from "@11ty/dependency-tree-esm";
+import { TemplatePath } from "@11ty/eleventy-utils";
+
+import EleventyBaseError from "../Errors/EleventyBaseError.js";
+
+class JavaScriptDependencies {
+	static getErrorMessage(file, type) {
+		return `A problem was encountered looking for JavaScript dependencies in ${type} file: ${file}. This only affects --watch and --serve behavior and does not affect your build.`;
+	}
+
+	static async getDependencies(inputFiles, isProjectUsingEsm) {
+		let depSet = new Set();
+
+		// TODO does this need to work with aliasing? what other JS extensions will have deps?
+		let commonJsFiles = inputFiles.filter(
+			(file) => (!isProjectUsingEsm && file.endsWith(".js")) || file.endsWith(".cjs"),
+		);
+
+		for (let file of commonJsFiles) {
+			try {
+				let modules = dependencyTree(file, {
+					nodeModuleNames: "exclude",
+					allowNotFound: true,
+				}).map((dependency) => {
+					return TemplatePath.addLeadingDotSlash(TemplatePath.relativePath(dependency));
+				});
+
+				for (let dep of modules) {
+					depSet.add(dep);
+				}
+			} catch (e) {
+				throw new EleventyBaseError(this.getErrorMessage(file, "CommonJS"), e);
+			}
+		}
+
+		let esmFiles = inputFiles.filter(
+			(file) => (isProjectUsingEsm && file.endsWith(".js")) || file.endsWith(".mjs"),
+		);
+		for (let file of esmFiles) {
+			try {
+				let modules = await find(file);
+				for (let dep of modules) {
+					depSet.add(dep);
+				}
+			} catch (e) {
+				throw new EleventyBaseError(this.getErrorMessage(file, "ESM"), e);
+			}
+		}
+
+		return Array.from(depSet).sort();
+	}
+}
+
+export default JavaScriptDependencies;

package/eleventy/node_modules/@11ty/eleventy/src/Util/MemoizeFunction.js

@@ -0,0 +1,26 @@
+export default function (callback, options = {}) {
+	let { bench, name } = options;
+	let cache = new Map();
+
+	return (...args) => {
+		// Only supports single-arg functions for now.
+		if (args.filter(Boolean).length > 1) {
+			bench?.get(`(count) ${name} Not valid for memoize`).incrementCount();
+			return callback(...args);
+		}
+
+		let [cacheKey] = args;
+
+		if (!cache.has(cacheKey)) {
+			cache.set(cacheKey, callback(...args));
+
+			bench?.get(`(count) ${name} memoize miss`).incrementCount();
+
+			return cache.get(cacheKey);
+		}
+
+		bench?.get(`(count) ${name} memoize hit`).incrementCount();
+
+		return cache.get(cacheKey);
+	};
+}

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/DeepFreeze.js

@@ -0,0 +1,20 @@
+import { isPlainObject } from "@11ty/eleventy-utils";
+
+// via https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+
+function DeepFreeze(obj, topLevelExceptions) {
+	for (let name of Reflect.ownKeys(obj)) {
+		if ((topLevelExceptions || []).find((key) => key === name)) {
+			continue;
+		}
+
+		const value = obj[name];
+		if (isPlainObject(value)) {
+			DeepFreeze(value);
+		}
+	}
+
+	return Object.freeze(obj);
+}
+
+export { DeepFreeze };

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/ObjectFilter.js

@@ -0,0 +1,9 @@
+export default function objectFilter(obj, callback) {
+	let newObject = {};
+	for (let [key, value] of Object.entries(obj || {})) {
+		if (callback(value, key)) {
+			newObject[key] = value;
+		}
+	}
+	return newObject;
+}

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/ProxyWrap.js

@@ -0,0 +1,111 @@
+import types from "node:util/types";
+import debugUtil from "debug";
+import { isPlainObject } from "@11ty/eleventy-utils";
+
+const debug = debugUtil("Dev:Eleventy:Proxy");
+
+function wrapObject(target, fallback) {
+	if (Object.isFrozen(target)) {
+		return target;
+	}
+
+	return new Proxy(target, {
+		getOwnPropertyDescriptor(target, prop) {
+			let ret;
+
+			if (Reflect.has(target, prop)) {
+				ret = Reflect.getOwnPropertyDescriptor(target, prop);
+			} else if (Reflect.has(fallback, prop)) {
+				ret = Reflect.getOwnPropertyDescriptor(fallback, prop);
+			}
+
+			return ret;
+		},
+		has(target, prop) {
+			if (Reflect.has(target, prop)) {
+				return true;
+			}
+
+			return Reflect.has(fallback, prop);
+		},
+		ownKeys(target) {
+			let s = new Set();
+			for (let k of Reflect.ownKeys(target)) {
+				s.add(k);
+			}
+			if (isPlainObject(fallback)) {
+				for (let k of Reflect.ownKeys(fallback)) {
+					s.add(k);
+				}
+			}
+			return Array.from(s);
+		},
+		get(target, prop) {
+			debug("handler:get", prop);
+
+			let value = Reflect.get(target, prop);
+
+			if (Reflect.has(target, prop)) {
+				// Already proxied
+				if (types.isProxy(value)) {
+					return value;
+				}
+
+				if (isPlainObject(value) && Reflect.has(fallback, prop)) {
+					if (Object.isFrozen(value)) {
+						return value;
+					}
+
+					let ret = wrapObject(value, Reflect.get(fallback, prop));
+					debug("handler:get (primary, object)", prop);
+					return ret;
+				}
+
+				debug("handler:get (primary)", prop);
+				return value;
+			}
+
+			// Does not exist in primary
+			if (Reflect.has(fallback, prop)) {
+				// fallback has prop
+				let fallbackValue = Reflect.get(fallback, prop);
+
+				if (isPlainObject(fallbackValue)) {
+					if (Object.isFrozen(fallbackValue)) {
+						return fallbackValue;
+					}
+
+					debug("handler:get (fallback, object)", prop);
+					// set empty object on primary
+					let emptyObject = {};
+					Reflect.set(target, prop, emptyObject);
+
+					return wrapObject(emptyObject, fallbackValue);
+				}
+
+				debug("handler:get (fallback)", prop);
+				return fallbackValue;
+			}
+
+			// primary *and* fallback do _not_ have prop
+			debug("handler:get (not on primary or fallback)", prop);
+
+			return value;
+		},
+		set(target, prop, value) {
+			debug("handler:set", prop);
+
+			return Reflect.set(target, prop, value);
+		},
+	});
+}
+
+function ProxyWrap(target, fallback) {
+	if (!isPlainObject(target) || !isPlainObject(fallback)) {
+		throw new Error("ProxyWrap expects objects for both the target and fallback");
+	}
+
+	return wrapObject(target, fallback);
+}
+
+export { ProxyWrap };

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/SampleModule.mjs

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

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/Sortable.js

@@ -0,0 +1,136 @@
+class Sortable {
+	constructor() {
+		this.isSortAscending = true;
+		this.isSortNumeric = false;
+		this.items = [];
+		this._dirty = true;
+
+		this.sortFunctionStringMap = {
+			"A-Z": "sortFunctionAscending",
+			"Z-A": "sortFunctionDescending",
+			"0-9": "sortFunctionNumericAscending",
+			"9-0": "sortFunctionNumericDescending",
+		};
+	}
+
+	get length() {
+		return this.items.length;
+	}
+
+	add(item) {
+		this._dirty = true;
+		this.items.push(item);
+	}
+
+	sort(sortFunction) {
+		if (!sortFunction) {
+			sortFunction = this.getSortFunction();
+		} else if (typeof sortFunction === "string") {
+			let key = sortFunction;
+			let name;
+			if (key in this.sortFunctionStringMap) {
+				name = this.sortFunctionStringMap[key];
+			}
+			if (Sortable[name]) {
+				sortFunction = Sortable[name];
+			} else {
+				throw new Error(
+					`Invalid String argument for sort(). Received \`${key}\`. Valid values: ${Object.keys(
+						this.sortFunctionStringMap,
+					)}`,
+				);
+			}
+		}
+
+		return this.items.slice().sort(sortFunction);
+	}
+
+	sortAscending() {
+		return this.sort(this.getSortFunctionAscending());
+	}
+
+	sortDescending() {
+		return this.sort(this.getSortFunctionDescending());
+	}
+
+	setSortDescending(isDescending = true) {
+		this.isSortAscending = !isDescending;
+	}
+
+	setSortAscending(isAscending = true) {
+		this.isSortAscending = isAscending;
+	}
+
+	setSortNumeric(isNumeric) {
+		this.isSortNumeric = isNumeric;
+	}
+
+	/* Sort functions */
+	static sortFunctionNumericAscending(a, b) {
+		return a - b;
+	}
+
+	static sortFunctionNumericDescending(a, b) {
+		return b - a;
+	}
+
+	static sortFunctionAscending(a, b) {
+		if (a > b) {
+			return 1;
+		} else if (a < b) {
+			return -1;
+		}
+		return 0;
+	}
+
+	static sortFunctionDescending(a, b) {
+		return Sortable.sortFunctionAscending(b, a);
+	}
+
+	static sortFunctionAlphabeticAscending(a, b) {
+		return Sortable.sortFunctionAscending(a, b);
+	}
+
+	static sortFunctionAlphabeticDescending(a, b) {
+		return Sortable.sortFunctionAscending(b, a);
+	}
+
+	static sortFunctionDate(mapA, mapB) {
+		return Sortable.sortFunctionNumericAscending(mapA.date.getTime(), mapB.date.getTime());
+	}
+
+	static sortFunctionDateInputPath(mapA, mapB) {
+		let sortDate = Sortable.sortFunctionNumericAscending(mapA.date.getTime(), mapB.date.getTime());
+		if (sortDate === 0) {
+			return Sortable.sortFunctionAlphabeticAscending(mapA.inputPath, mapB.inputPath);
+		}
+		return sortDate;
+	}
+	/* End sort functions */
+
+	getSortFunction() {
+		if (this.isSortAscending) {
+			return this.getSortFunctionAscending();
+		} else {
+			return this.getSortFunctionDescending();
+		}
+	}
+
+	getSortFunctionAscending() {
+		if (this.isSortNumeric) {
+			return Sortable.sortFunctionNumericAscending;
+		} else {
+			return Sortable.sortFunctionAlphabeticAscending;
+		}
+	}
+
+	getSortFunctionDescending() {
+		if (this.isSortNumeric) {
+			return Sortable.sortFunctionNumericDescending;
+		} else {
+			return Sortable.sortFunctionAlphabeticDescending;
+		}
+	}
+}
+
+export default Sortable;

package/eleventy/node_modules/@11ty/eleventy/src/Util/Objects/Unique.js

@@ -0,0 +1,3 @@
+export default function Unique(arr) {
+	return Array.from(new Set(arr));
+}

package/eleventy/node_modules/@11ty/eleventy/src/Util/PassthroughCopyBehaviorCheck.js

@@ -0,0 +1,16 @@
+function isUsingEleventyDevServer(config) {
+	return (
+		!config.serverOptions.module || config.serverOptions.module === "@11ty/eleventy-dev-server"
+	);
+}
+
+// Config opt-out via serverPassthroughCopyBehavior
+// False when other server is used
+// False when runMode is "build" or "watch"
+export default function (config, runMode) {
+	return (
+		config.serverPassthroughCopyBehavior === "passthrough" &&
+		isUsingEleventyDevServer(config) &&
+		runMode === "serve"
+	);
+}

package/eleventy/node_modules/@11ty/eleventy/src/Util/PathNormalizer.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { TemplatePath } from "@11ty/eleventy-utils";
+
+class PathNormalizer {
+	static getParts(inputPath) {
+		if (!inputPath) {
+			return [];
+		}
+
+		let separator = "/";
+		if (inputPath.includes(path.sep)) {
+			separator = path.sep;
+		}
+
+		return inputPath.split(separator).filter((entry) => entry !== ".");
+	}
+
+	// order is important here: the top-most directory returns first
+	// array of file and all parent directories
+	static getAllPaths(inputPath) {
+		let parts = this.getParts(inputPath);
+		let allPaths = [];
+
+		let fullpath = "";
+		for (let part of parts) {
+			fullpath += (fullpath.length > 0 ? "/" : "") + part;
+			allPaths.push(fullpath);
+		}
+
+		return allPaths;
+	}
+
+	static normalizeSeperator(inputPath) {
+		if (!inputPath) {
+			return inputPath;
+		}
+		return inputPath.split(path.sep).join("/");
+	}
+
+	static fullNormalization(inputPath) {
+		if (typeof inputPath !== "string") {
+			return inputPath;
+		}
+
+		// Fix file:///Users/ or file:///C:/ paths passed in
+		if (inputPath.startsWith("file://")) {
+			inputPath = fileURLToPath(inputPath);
+		}
+
+		// Paths should not be absolute (we convert absolute paths to relative)
+		// Paths should not have a leading dot slash
+		// Paths should always be `/` independent of OS path separator
+		return TemplatePath.stripLeadingDotSlash(
+			this.normalizeSeperator(TemplatePath.relativePath(inputPath)),
+		);
+	}
+}
+
+export default PathNormalizer;

package/eleventy/node_modules/@11ty/eleventy/src/Util/PathPrefixer.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+
+import PathNormalizer from "./PathNormalizer.js";
+
+class PathPrefixer {
+	static normalizePathPrefix(pathPrefix) {
+		if (pathPrefix) {
+			// add leading / (for browsersync), see #1454
+			// path.join uses \\ for Windows so we split and rejoin
+			return PathPrefixer.joinUrlParts("/", pathPrefix);
+		}
+
+		return "/";
+	}
+
+	static joinUrlParts(...parts) {
+		return PathNormalizer.normalizeSeperator(path.join(...parts));
+	}
+}
+
+export default PathPrefixer;

package/eleventy/node_modules/@11ty/eleventy/src/Util/Pluralize.js

@@ -0,0 +1,3 @@
+export default function (count, singleWord, pluralWord) {
+	return count === 1 ? singleWord : pluralWord;
+}