@cloudflare/pages-shared 0.0.0-ship-js

package/asset-server/patchUrl.ts

@@ -0,0 +1,22 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+globalThis.URL = (function (globalURL) {
+	PatchedURL.prototype = globalURL.prototype;
+	PatchedURL.createObjectURL = globalURL.createObjectURL;
+	PatchedURL.revokeObjectURL = globalURL.revokeObjectURL;
+
+	return PatchedURL as unknown as typeof globalURL;
+
+	function PatchedURL(input: string, base?: string | URL) {
+		const url = new globalURL(encodeURI(input), base);
+
+		return new Proxy(url, {
+			get(target, prop) {
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				return globalThis.decodeURIComponent((target as any)[prop]);
+			},
+		});
+	}
+})(URL);
+
+export {};

package/asset-server/responses.ts

@@ -0,0 +1,196 @@
+type HeadersInit = ConstructorParameters<typeof Headers>[0];
+
+function mergeHeaders(base: HeadersInit, extra: HeadersInit) {
+	base = new Headers(base ?? {});
+	extra = new Headers(extra ?? {});
+
+	return new Headers({
+		...Object.fromEntries(base.entries()),
+		...Object.fromEntries(extra.entries()),
+	});
+}
+
+export function stripLeadingDoubleSlashes(location: string) {
+	return location.replace(/^(\/|%2F|%2f|%5C|%5c|\\)+(.*)/, "/$2");
+}
+
+export class OkResponse extends Response {
+	constructor(...[body, init]: ConstructorParameters<typeof Response>) {
+		super(body, {
+			...init,
+			status: 200,
+			statusText: "OK",
+		});
+	}
+}
+
+export class MovedPermanentlyResponse extends Response {
+	constructor(
+		location: string,
+		init?: ConstructorParameters<typeof Response>[1],
+		{
+			preventLeadingDoubleSlash = true,
+		}: { preventLeadingDoubleSlash: boolean } = {
+			preventLeadingDoubleSlash: true,
+		}
+	) {
+		location = preventLeadingDoubleSlash
+			? stripLeadingDoubleSlashes(location)
+			: location;
+		super(`Redirecting to ${location}`, {
+			...init,
+			status: 301,
+			statusText: "Moved Permanently",
+			headers: mergeHeaders(init?.headers, {
+				location,
+			}),
+		});
+	}
+}
+
+export class FoundResponse extends Response {
+	constructor(
+		location: string,
+		init?: ConstructorParameters<typeof Response>[1],
+		{
+			preventLeadingDoubleSlash = true,
+		}: { preventLeadingDoubleSlash: boolean } = {
+			preventLeadingDoubleSlash: true,
+		}
+	) {
+		location = preventLeadingDoubleSlash
+			? stripLeadingDoubleSlashes(location)
+			: location;
+		super(`Redirecting to ${location}`, {
+			...init,
+			status: 302,
+			statusText: "Found",
+			headers: mergeHeaders(init?.headers, {
+				location,
+			}),
+		});
+	}
+}
+
+export class NotModifiedResponse extends Response {
+	constructor(...[_body, _init]: ConstructorParameters<typeof Response>) {
+		super(undefined, {
+			status: 304,
+			statusText: "Not Modified",
+		});
+	}
+}
+
+export class PermanentRedirectResponse extends Response {
+	constructor(
+		location: string,
+		init?: ConstructorParameters<typeof Response>[1],
+		{
+			preventLeadingDoubleSlash = true,
+		}: { preventLeadingDoubleSlash: boolean } = {
+			preventLeadingDoubleSlash: true,
+		}
+	) {
+		location = preventLeadingDoubleSlash
+			? stripLeadingDoubleSlashes(location)
+			: location;
+		super(undefined, {
+			...init,
+			status: 308,
+			statusText: "Permanent Redirect",
+			headers: mergeHeaders(init?.headers, {
+				location,
+			}),
+		});
+	}
+}
+
+export class NotFoundResponse extends Response {
+	constructor(...[body, init]: ConstructorParameters<typeof Response>) {
+		super(body, {
+			...init,
+			status: 404,
+			statusText: "Not Found",
+		});
+	}
+}
+
+export class MethodNotAllowedResponse extends Response {
+	constructor(...[body, init]: ConstructorParameters<typeof Response>) {
+		super(body, {
+			...init,
+			status: 405,
+			statusText: "Method Not Allowed",
+		});
+	}
+}
+
+export class NotAcceptableResponse extends Response {
+	constructor(...[body, init]: ConstructorParameters<typeof Response>) {
+		super(body, {
+			...init,
+			status: 406,
+			statusText: "Not Acceptable",
+		});
+	}
+}
+
+export class InternalServerErrorResponse extends Response {
+	constructor(err: Error, init?: ConstructorParameters<typeof Response>[1]) {
+		let body: string | undefined = undefined;
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		if ((globalThis as any).DEBUG) {
+			body = `${err.message}\n\n${err.stack}`;
+		}
+
+		super(body, {
+			...init,
+			status: 500,
+			statusText: "Internal Server Error",
+		});
+	}
+}
+
+export class SeeOtherResponse extends Response {
+	constructor(
+		location: string,
+		init?: ConstructorParameters<typeof Response>[1],
+		{
+			preventLeadingDoubleSlash = true,
+		}: { preventLeadingDoubleSlash: boolean } = {
+			preventLeadingDoubleSlash: true,
+		}
+	) {
+		location = preventLeadingDoubleSlash
+			? stripLeadingDoubleSlashes(location)
+			: location;
+		super(`Redirecting to ${location}`, {
+			...init,
+			status: 303,
+			statusText: "See Other",
+			headers: mergeHeaders(init?.headers, { location }),
+		});
+	}
+}
+
+export class TemporaryRedirectResponse extends Response {
+	constructor(
+		location: string,
+		init?: ConstructorParameters<typeof Response>[1],
+		{
+			preventLeadingDoubleSlash = true,
+		}: { preventLeadingDoubleSlash: boolean } = {
+			preventLeadingDoubleSlash: true,
+		}
+	) {
+		location = preventLeadingDoubleSlash
+			? stripLeadingDoubleSlashes(location)
+			: location;
+		super(`Redirecting to ${location}`, {
+			...init,
+			status: 307,
+			statusText: "Temporary Redirect",
+			headers: mergeHeaders(init?.headers, { location }),
+		});
+	}
+}

package/asset-server/rulesEngine.ts

@@ -0,0 +1,82 @@
+// Taken from https://stackoverflow.com/a/3561711
+// which is everything from the tc39 proposal, plus the following two characters: ^/
+// It's also everything included in the URLPattern escape (https://wicg.github.io/urlpattern/#escape-a-regexp-string), plus the following: -
+// As the answer says, there's no downside to escaping these extra characters, so better safe than sorry
+const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+const escapeRegex = (str: string) => {
+	return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};
+
+// Placeholder names must begin with a colon, be alphanumeric and optionally contain underscores.
+// e.g. :place_123_holder
+const HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g;
+const PLACEHOLDER_REGEX = /:(\w+)/g;
+
+export type Replacements = Record<string, string>;
+
+export type Removals = string[];
+
+export const replacer = (str: string, replacements: Replacements) => {
+	for (const [replacement, value] of Object.entries(replacements)) {
+		str = str.replaceAll(`:${replacement}`, value);
+	}
+	return str;
+};
+
+export const generateRulesMatcher = <T>(
+	rules?: Record<string, T>,
+	replacerFn: (match: T, replacements: Replacements) => T = (match) => match
+) => {
+	if (!rules) return () => [];
+
+	const compiledRules = Object.entries(rules)
+		.map(([rule, match]) => {
+			const crossHost = rule.startsWith("https://");
+
+			// Create :splat capturer then escape.
+			rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+
+			// Create :placeholder capturers (already escaped).
+			// For placeholders in the host, we separate at forward slashes and periods.
+			// For placeholders in the path, we separate at forward slashes.
+			// This matches the behavior of URLPattern.
+			// e.g. https://:subdomain.domain/ -> https://(here).domain/
+			// e.g. /static/:file -> /static/(image.jpg)
+			// e.g. /blog/:post -> /blog/(an-exciting-post)
+			const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+			for (const host_match of host_matches) {
+				rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+			}
+
+			const path_matches = rule.matchAll(PLACEHOLDER_REGEX);
+			for (const path_match of path_matches) {
+				rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+			}
+
+			// Wrap in line terminators to be safe.
+			rule = "^" + rule + "$";
+
+			try {
+				const regExp = new RegExp(rule);
+				return [{ crossHost, regExp }, match];
+			} catch {}
+		})
+		.filter((value) => value !== undefined) as [
+		{ crossHost: boolean; regExp: RegExp },
+		T
+	][];
+
+	return ({ request }: { request: Request }) => {
+		const { pathname, host } = new URL(request.url);
+
+		return compiledRules
+			.map(([{ crossHost, regExp }, match]) => {
+				const test = crossHost ? `https://${host}${pathname}` : pathname;
+				const result = regExp.exec(test);
+				if (result) {
+					return replacerFn(match, result.groups || {});
+				}
+			})
+			.filter((value) => value !== undefined) as T[];
+	};
+};

package/dist/__tests__/asset-server/handler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=handler.test.d.ts.map

package/dist/__tests__/asset-server/handler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.test.d.ts","sourceRoot":"","sources":["../../../__tests__/asset-server/handler.test.ts"],"names":[],"mappings":""}