@libsrcdev/gatsby-remark-images-anywhere 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,12 +1,13 @@
 import { Node, NodePluginArgs } from "gatsby";
 import { FileSystemNode } from "gatsby-source-filesystem";
-import { Literal } from "mdast";
+import { Literal, Literal as RemarkLiteral, Node as RemarkNode } from "mdast";
 
 //#region src/custom-http-headers/http-request-header-options.d.ts
 type HttpRequestHeaderOptions = {
   dangerouslyBuildRequestHttpHeaders?: (url: string) => Record<string, string> | undefined;
-  httpHeaderProviders: ((url: string) => Record<string, string> | undefined)[];
+  httpHeaderProviders?: HttpRequestHeaderProvider[];
 };
+type HttpRequestHeaderProvider = (url: string) => Record<string, string> | undefined;
 //#endregion
 //#region src/type.d.ts
 type SharpMethod = 'fluid' | 'fixed' | 'resize';
@@ -54,6 +55,87 @@ interface Options extends Partial<MarkupOptions>, HttpRequestHeaderOptions {
   [key: string]: unknown;
 }
 //#endregion
+//#region src/constants.d.ts
+declare const CLASS_WRAPPER = "gria-image-wrapper";
+declare const CLASS_PADDING = "gria-image-padding";
+declare const CLASS_LINK = "gria-image-link";
+declare const CLASS_IMAGE = "gria-image";
+declare const CLASS_PLACEHOLDER = "gria-image-placeholder";
+declare const SUPPORT_EXTS: string[];
+//#endregion
+//#region src/custom-http-headers/is-trusted-url.d.ts
+type UrlCheckOptions = {
+  allowedDomains: string[];
+  schemes?: string[];
+  allowSubdomains?: boolean;
+  maxSubdomainDepth?: number;
+  allowedPorts?: string[] | null;
+  disallowedQueryParams?: string[];
+};
+declare function isTrustedUrl(input: string, options: UrlCheckOptions): boolean;
+//#endregion
+//#region src/custom-http-headers/http-header-trusted-provider.d.ts
+declare function httpHeaderTrustedProvider(options: UrlCheckOptions, headerBuilder: (url: string) => Record<string, string> | undefined): (url: string) => Record<string, string> | undefined;
+declare function forTrustedDomains(domains: string[], headerBuilder: (url: string) => Record<string, string> | undefined): (url: string) => Record<string, string> | undefined;
+declare const buildRequestHttpHeadersWith: (httpHeaderProviders: HttpRequestHeaderProvider[]) => (url: string) => Record<string, string> | undefined;
+//#endregion
+//#region src/default-markup.d.ts
+declare const defaultMarkup: CreateMarkup;
+//#endregion
+//#region src/relative-protocol-whitelist.d.ts
+type MakeWhitelistTest = (whitelist: string[]) => (url: string) => boolean;
+declare const makeWhitelistTest: MakeWhitelistTest;
+declare const isWhitelisted: (url: string) => boolean;
+//#endregion
+//#region src/util-download-image.d.ts
+declare const downloadImage: ({
+  id,
+  url,
+  getCache,
+  getNode,
+  touchNode,
+  cache,
+  createNode,
+  createNodeId,
+  reporter,
+  dangerouslyBuildImageRequestHttpHeaders
+}: any) => Promise<any>;
+declare const processImage: ({
+  file,
+  reporter,
+  cache,
+  pathPrefix,
+  sharpMethod,
+  imageOptions
+}: {
+  sharpMethod: SharpMethod;
+} & {
+  [key: string]: any;
+}) => Promise<SharpResult>;
+//#endregion
+//#region src/util-html-to-md.d.ts
+type RemarkImageNode = RemarkLiteral & {
+  url?: string;
+  title?: string;
+  alt?: string;
+  data: Record<string, any>;
+};
+declare const toMdNode: (node: RemarkLiteral) => RemarkImageNode | null;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Resolves a potentially incomplete URL to a full URL with protocol
+ * @param url - The URL to resolve (can be protocol-relative or full)
+ * @returns The full URL with protocol, or null if invalid or relative
+ */
+declare function resolveFullUrl(url: string): string | undefined;
+/**
+ * Resolves a relative URL by validating and returning it if it's relative
+ * @param url - The URL to check and resolve
+ * @returns The relative URL if valid, or undefined if not relative or invalid
+ */
+declare function resolveRelativeUrl(url: string): string | undefined;
+//#endregion
 //#region src/index.d.ts
 declare function remarkImagesAnywhere({
   markdownAST: mdast,
@@ -68,4 +150,5 @@ declare function remarkImagesAnywhere({
   cache,
   pathPrefix
 }: Args, pluginOptions: Options): Promise<(null | undefined)[]>;
-export = remarkImagesAnywhere;
+//#endregion
+export { Args, CLASS_IMAGE, CLASS_LINK, CLASS_PADDING, CLASS_PLACEHOLDER, CLASS_WRAPPER, CreateMarkup, CreateMarkupArgs, HttpRequestHeaderOptions, HttpRequestHeaderProvider, MarkupOptions, Options, RemarkImageNode, type RemarkLiteral, type RemarkNode, SUPPORT_EXTS, SharpMethod, SharpResult, UrlCheckOptions, buildRequestHttpHeadersWith, remarkImagesAnywhere as default, defaultMarkup, downloadImage, forTrustedDomains, httpHeaderTrustedProvider, isTrustedUrl, isWhitelisted, makeWhitelistTest, processImage, resolveFullUrl, resolveRelativeUrl, toMdNode };

package/dist/index.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, '__esModule', { value: true });
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -32,6 +33,8 @@ let unist_util_select = require("unist-util-select");
 let slash = require("slash");
 slash = __toESM(slash);
 let parse5 = require("parse5");
+let is_relative_url = require("is-relative-url");
+is_relative_url = __toESM(is_relative_url);
 
 //#region node_modules/universalify/index.js
 var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -70916,22 +70919,99 @@ const makeWhitelistTest = (whitelist) => (url$3) => {
 const isWhitelisted = makeWhitelistTest(rpWhitelist);
 
 //#endregion
-//#region src/custom-http-headers/http-header-trusted-provider.ts
-function createRequestHttpHeaderBuilder({ dangerouslyBuildRequestHttpHeaders, httpHeaderProviders }) {
-	if (dangerouslyBuildRequestHttpHeaders) return dangerouslyBuildRequestHttpHeaders;
-	if (httpHeaderProviders) return (url$3) => {
-		for (const httpHeaderProvider of httpHeaderProviders) {
-			const httpHeaders = httpHeaderProvider(url$3);
-			if (httpHeaders) return httpHeaders;
+//#region src/custom-http-headers/is-trusted-url.ts
+function isTrustedUrl(input, options) {
+	const { allowedDomains, schemes = ["http", "https"], allowSubdomains = false, maxSubdomainDepth = Infinity, allowedPorts = null, disallowedQueryParams = [] } = options;
+	try {
+		const url$3 = new URL(input);
+		const protocol = url$3.protocol.replace(":", "");
+		if (!schemes.includes(protocol)) return false;
+		const hostname = url$3.hostname.toLowerCase();
+		let domainMatch = false;
+		for (const allowedDomain of allowedDomains) {
+			const domain = allowedDomain.toLowerCase();
+			if (hostname === domain) {
+				domainMatch = true;
+				break;
+			}
+			if (allowSubdomains && hostname.endsWith("." + domain)) {
+				if (hostname.slice(0, -(domain.length + 1)).split(".").length <= maxSubdomainDepth) {
+					domainMatch = true;
+					break;
+				}
+			}
+		}
+		if (!domainMatch) return false;
+		if (disallowedQueryParams.length > 0) {
+			for (const param of disallowedQueryParams) if (url$3.searchParams.has(param)) return false;
+		}
+		if (allowedPorts) {
+			const port = url$3.port || (protocol === "https" ? "443" : protocol === "http" ? "80" : "");
+			if (!allowedPorts.includes(port)) return false;
 		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/custom-http-headers/http-header-trusted-provider.ts
+function httpHeaderTrustedProvider(options, headerBuilder) {
+	return (url$3) => {
+		if (!isTrustedUrl(url$3, options)) return;
+		return headerBuilder(url$3);
 	};
-	return (_$2) => void 0;
+}
+function forTrustedDomains(domains, headerBuilder) {
+	return httpHeaderTrustedProvider({
+		allowedDomains: domains,
+		allowSubdomains: false
+	}, headerBuilder);
+}
+const buildRequestHttpHeadersWith = (httpHeaderProviders) => (url$3) => {
+	for (const httpHeaderProvider of httpHeaderProviders ?? []) {
+		const httpHeaders = httpHeaderProvider(url$3);
+		if (httpHeaders) return httpHeaders;
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/**
+* Resolves a potentially incomplete URL to a full URL with protocol
+* @param url - The URL to resolve (can be protocol-relative or full)
+* @returns The full URL with protocol, or null if invalid or relative
+*/
+function resolveFullUrl(url$3) {
+	const trimmed = url$3.trim();
+	if (!trimmed) return;
+	if ((0, is_relative_url.default)(trimmed)) return;
+	let resolvedUrl = trimmed;
+	if (trimmed.startsWith("//")) resolvedUrl = `https:${trimmed}`;
+	try {
+		new URL(resolvedUrl);
+		return resolvedUrl;
+	} catch {
+		return;
+	}
+}
+/**
+* Resolves a relative URL by validating and returning it if it's relative
+* @param url - The URL to check and resolve
+* @returns The relative URL if valid, or undefined if not relative or invalid
+*/
+function resolveRelativeUrl(url$3) {
+	const trimmed = url$3.trim();
+	if (!trimmed) return;
+	if (!(0, is_relative_url.default)(trimmed)) return;
+	return trimmed;
 }
 
 //#endregion
 //#region src/index.ts
 async function remarkImagesAnywhere({ markdownAST: mdast, markdownNode, actions: actions$1, store, files, getNode, getCache, createNodeId, reporter, cache: cache$3, pathPrefix }, pluginOptions$1) {
-	const { plugins, staticDir = "static", createMarkup = defaultMarkup, sharpMethod = "fluid", loading = "lazy", linkImagesToOriginal = false, showCaptions = false, wrapperStyle = "", backgroundColor = "#fff", tracedSVG = false, blurUp = true, dangerouslyBuildRequestHttpHeaders, httpHeaderProviders, ...imageOptions } = pluginOptions$1;
+	const { plugins, staticDir = "static", createMarkup = defaultMarkup, sharpMethod = "fluid", loading = "lazy", linkImagesToOriginal = false, showCaptions = false, wrapperStyle = "", backgroundColor = "#fff", tracedSVG = false, blurUp = true, dangerouslyBuildRequestHttpHeaders, httpHeaderProviders = [], ...imageOptions } = pluginOptions$1;
 	if ([
 		"fluid",
 		"fixed",
@@ -70948,27 +71028,28 @@ async function remarkImagesAnywhere({ markdownAST: mdast, markdownNode, actions:
 		let url$3 = node.url;
 		let gImgFileNode;
 		if (isWhitelisted(url$3)) url$3 = `https:${url$3}`;
-		if (url$3.startsWith("http")) gImgFileNode = await downloadImage({
-			id: markdownNode.id,
-			url: url$3,
-			getCache,
-			getNode,
-			touchNode,
-			cache: cache$3,
-			createNode,
-			createNodeId,
-			reporter,
-			dangerouslyBuildImageRequestHttpHeaders: createRequestHttpHeaderBuilder({
-				dangerouslyBuildRequestHttpHeaders,
-				httpHeaderProviders
-			})
-		});
-		else {
+		const remoteFullImageUrl = resolveFullUrl(url$3);
+		const relativeImageUrl = resolveRelativeUrl(url$3);
+		if (remoteFullImageUrl) {
+			const buildRequestHttpHeaders = dangerouslyBuildRequestHttpHeaders ?? buildRequestHttpHeadersWith(httpHeaderProviders);
+			gImgFileNode = await downloadImage({
+				id: markdownNode.id,
+				url: new URL(url$3).protocol,
+				getCache,
+				getNode,
+				touchNode,
+				cache: cache$3,
+				createNode,
+				createNodeId,
+				reporter,
+				dangerouslyBuildImageRequestHttpHeaders: buildRequestHttpHeaders
+			});
+		} else if (relativeImageUrl) {
 			let filePath;
 			if (dirPath && url$3[0] === ".") filePath = (0, slash.default)(path.default.join(dirPath, url$3));
 			else filePath = path.default.join(directory, staticDir, url$3);
 			gImgFileNode = files.find((fileNode) => fileNode.absolutePath && fileNode.absolutePath === filePath);
-		}
+		} else reporter.warn(`Skipping invalid image URL ${url$3}`);
 		if (!gImgFileNode) return;
 		if (!SUPPORT_EXTS.includes(gImgFileNode.extension)) return;
 		const imageResult = await processImage({
@@ -71003,4 +71084,22 @@ async function remarkImagesAnywhere({ markdownAST: mdast, markdownNode, actions:
 }
 
 //#endregion
-module.exports = remarkImagesAnywhere;
+exports.CLASS_IMAGE = CLASS_IMAGE;
+exports.CLASS_LINK = CLASS_LINK;
+exports.CLASS_PADDING = CLASS_PADDING;
+exports.CLASS_PLACEHOLDER = CLASS_PLACEHOLDER;
+exports.CLASS_WRAPPER = CLASS_WRAPPER;
+exports.SUPPORT_EXTS = SUPPORT_EXTS;
+exports.buildRequestHttpHeadersWith = buildRequestHttpHeadersWith;
+exports.default = remarkImagesAnywhere;
+exports.defaultMarkup = defaultMarkup;
+exports.downloadImage = downloadImage;
+exports.forTrustedDomains = forTrustedDomains;
+exports.httpHeaderTrustedProvider = httpHeaderTrustedProvider;
+exports.isTrustedUrl = isTrustedUrl;
+exports.isWhitelisted = isWhitelisted;
+exports.makeWhitelistTest = makeWhitelistTest;
+exports.processImage = processImage;
+exports.resolveFullUrl = resolveFullUrl;
+exports.resolveRelativeUrl = resolveRelativeUrl;
+exports.toMdNode = toMdNode;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@libsrcdev/gatsby-remark-images-anywhere",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "Handle images with relative, absolute, remote path for gatsby-transformer-remark.",
 	"keywords": [
 		"gatsby",
@@ -35,25 +35,26 @@
 		"prepare": "npm run build"
 	},
 	"dependencies": {
+		"is-relative-url": "^4.1.0",
 		"parse5": "^8.0.0",
 		"slash": "^3.0.0",
 		"unist-util-select": "^5.1.0"
 	},
 	"devDependencies": {
 		"@swc/core": "^1.15.3",
+		"@types/fs-extra": "^8.0.0",
 		"@types/mdast": "^4.0.4",
 		"eslint": "^9.39.1",
 		"gatsby": "^5.15.0",
+		"gatsby-plugin-sharp": "^5.10.0",
+		"gatsby-source-filesystem": "^5.10.0",
 		"husky": "^9.1.7",
 		"mdast": "^2.3.2",
 		"nodemon": "^3.1.11",
+		"tap": "^14.9.2",
 		"tsdown": "^0.16.6",
 		"tslib": "^2.8.1",
-		"typescript": "^5.9.3",
-		"@types/fs-extra": "^8.0.0",
-		"gatsby-plugin-sharp": "^5.10.0",
-		"gatsby-source-filesystem": "^5.10.0",
-		"tap": "^14.9.2"
+		"typescript": "^5.9.3"
 	},
 	"typings": "dist/index.d.ts",
 	"prettier": {
@@ -62,4 +63,4 @@
 		"singleQuote": true,
 		"trailingComma": "es5"
 	}
-}
+}