@sveltejs/kit 1.0.0-next.32 → 1.0.0-next.322

package/dist/chunks/url.js

@@ -0,0 +1,138 @@
+/**
+ * Takes zero or more objects and returns a new object that has all the values
+ * deeply merged together. None of the original objects will be mutated at any
+ * level, and the returned object will have no references to the original
+ * objects at any depth. If there's a conflict the last one wins, except for
+ * arrays which will be combined.
+ * @param {...Object} objects
+ * @returns {[Record<string, any>, string[]]} a 2-tuple with the merged object,
+ *     and a list of merge conflicts if there were any, in dotted notation
+ */
+function deep_merge(...objects) {
+	const result = {};
+	/** @type {string[]} */
+	const conflicts = [];
+	objects.forEach((o) => merge_into(result, o, conflicts));
+	return [result, conflicts];
+}
+
+/**
+ * normalize kit.vite.resolve.alias as an array
+ * @param {import('vite').AliasOptions} o
+ * @returns {import('vite').Alias[]}
+ */
+function normalize_alias(o) {
+	if (Array.isArray(o)) return o;
+	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
+}
+
+/**
+ * Merges b into a, recursively, mutating a.
+ * @param {Record<string, any>} a
+ * @param {Record<string, any>} b
+ * @param {string[]} conflicts array to accumulate conflicts in
+ * @param {string[]} path array of property names representing the current
+ *     location in the tree
+ */
+function merge_into(a, b, conflicts = [], path = []) {
+	/**
+	 * Checks for "plain old Javascript object", typically made as an object
+	 * literal. Excludes Arrays and built-in types like Buffer.
+	 * @param {any} x
+	 */
+	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
+
+	for (const prop in b) {
+		// normalize alias objects to array
+		if (prop === 'alias' && path[path.length - 1] === 'resolve') {
+			if (a[prop]) a[prop] = normalize_alias(a[prop]);
+			if (b[prop]) b[prop] = normalize_alias(b[prop]);
+		}
+
+		if (is_plain_object(b[prop])) {
+			if (!is_plain_object(a[prop])) {
+				if (a[prop] !== undefined) {
+					conflicts.push([...path, prop].join('.'));
+				}
+				a[prop] = {};
+			}
+			merge_into(a[prop], b[prop], conflicts, [...path, prop]);
+		} else if (Array.isArray(b[prop])) {
+			if (!Array.isArray(a[prop])) {
+				if (a[prop] !== undefined) {
+					conflicts.push([...path, prop].join('.'));
+				}
+				a[prop] = [];
+			}
+			a[prop].push(...b[prop]);
+		} else {
+			// Since we're inside a for/in loop which loops over enumerable
+			// properties only, we want parity here and to check if 'a' has
+			// enumerable-only property 'prop'. Using 'hasOwnProperty' to
+			// exclude inherited properties is close enough. It is possible
+			// that someone uses Object.defineProperty to create a direct,
+			// non-enumerable property but let's not worry about that.
+			if (Object.prototype.hasOwnProperty.call(a, prop)) {
+				conflicts.push([...path, prop].join('.'));
+			}
+			a[prop] = b[prop];
+		}
+	}
+}
+
+const absolute = /^([a-z]+:)?\/?\//;
+const scheme = /^[a-z]+:/;
+
+/**
+ * @param {string} base
+ * @param {string} path
+ */
+function resolve(base, path) {
+	if (scheme.test(path)) return path;
+
+	const base_match = absolute.exec(base);
+	const path_match = absolute.exec(path);
+
+	if (!base_match) {
+		throw new Error(`bad base path: "${base}"`);
+	}
+
+	const baseparts = path_match ? [] : base.slice(base_match[0].length).split('/');
+	const pathparts = path_match ? path.slice(path_match[0].length).split('/') : path.split('/');
+
+	baseparts.pop();
+
+	for (let i = 0; i < pathparts.length; i += 1) {
+		const part = pathparts[i];
+		if (part === '.') continue;
+		else if (part === '..') baseparts.pop();
+		else baseparts.push(part);
+	}
+
+	const prefix = (path_match && path_match[0]) || (base_match && base_match[0]) || '';
+
+	return `${prefix}${baseparts.join('/')}`;
+}
+
+/** @param {string} path */
+function is_root_relative(path) {
+	return path[0] === '/' && path[1] !== '/';
+}
+
+/**
+ * @param {string} path
+ * @param {import('types').TrailingSlash} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && !path.endsWith('/')) {
+		return path + '/';
+	}
+
+	return path;
+}
+
+export { deep_merge as d, is_root_relative as i, normalize_path as n, resolve as r };