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

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 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 = {
@@ -55,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,
@@ -69,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;
@@ -70917,8 +70918,57 @@ const makeWhitelistTest = (whitelist) => (url$3) => {
 };
 const isWhitelisted = makeWhitelistTest(rpWhitelist);
 
+//#endregion
+//#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);
+	};
+}
+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);
@@ -71034,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.3",
+	"version": "0.1.4",
 	"description": "Handle images with relative, absolute, remote path for gatsby-transformer-remark.",
 	"keywords": [
 		"gatsby",