@tryghost/url-utils 5.0.0-rc.1 → 5.1.0

package/lib/utils/transform-ready-to-absolute.js

@@ -1,14 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-
-function trimTrailingSlash(url) {
-    if (!url) {
-        return url;
-    }
-    return url.replace(/\/+$/, '');
-}
-
 const transformReadyToAbsolute = function (str = '', root, _options = {}) {
     const defaultOptions = {
         replacementStr: '__GHOST_URL__',
@@ -20,34 +14,22 @@ const transformReadyToAbsolute = function (str = '', root, _options = {}) {
         mediaBaseUrl: null
     };
     const options = Object.assign({}, defaultOptions, _options);
-
     if (!str || str.indexOf(options.replacementStr) === -1) {
         return str;
     }
-
     const replacementRegex = new RegExp(escapeRegExp(options.replacementStr), 'g');
-    const fallbackBase = trimTrailingSlash(options.imageBaseUrl || root);
-    const mediaBase = trimTrailingSlash(options.mediaBaseUrl);
-    const filesBase = trimTrailingSlash(options.filesBaseUrl);
-    const imageBase = trimTrailingSlash(options.imageBaseUrl) || fallbackBase;
-
     return str.replace(replacementRegex, (match, offset) => {
         const remainder = str.slice(offset + match.length);
-
-        if (options.staticMediaUrlPrefix && remainder.startsWith(`/${options.staticMediaUrlPrefix}`) && mediaBase) {
-            return mediaBase;
+        if (remainder.startsWith(`/${options.staticMediaUrlPrefix}`) && options.mediaBaseUrl) {
+            return options.mediaBaseUrl.replace(/\/$/, '');
         }
-
-        if (options.staticFilesUrlPrefix && remainder.startsWith(`/${options.staticFilesUrlPrefix}`) && filesBase) {
-            return filesBase;
+        if (remainder.startsWith(`/${options.staticFilesUrlPrefix}`) && options.filesBaseUrl) {
+            return options.filesBaseUrl.replace(/\/$/, '');
         }
-
-        if (options.staticImageUrlPrefix && remainder.startsWith(`/${options.staticImageUrlPrefix}`) && imageBase) {
-            return imageBase;
+        if (remainder.startsWith(`/${options.staticImageUrlPrefix}`) && options.imageBaseUrl) {
+            return options.imageBaseUrl.replace(/\/$/, '');
         }
-
-        return fallbackBase;
+        return root.replace(/\/$/, '');
     });
 };
-
-module.exports = transformReadyToAbsolute;
+exports.default = transformReadyToAbsolute;

package/lib/utils/transform-ready-to-relative.d.ts

@@ -0,0 +1,3 @@
+import type { TransformReadyReplacementOptionsInput } from './types';
+declare const transformReadyToRelative: (str: string | undefined, root: string, _options?: TransformReadyReplacementOptionsInput) => string;
+export default transformReadyToRelative;

package/lib/utils/transform-ready-to-relative.js

@@ -1,24 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-
 const transformReadyToRelative = function (str = '', root, _options = {}) {
     const defaultOptions = {
         replacementStr: '__GHOST_URL__'
     };
     const options = Object.assign({}, defaultOptions, _options);
-
     if (!str || str.indexOf(options.replacementStr) === -1) {
         return str;
     }
-
-    const rootURL = new URL(root);
+    const rootURL = new url_1.URL(root);
     // subdir with no trailing slash because we'll always have a trailing slash after the magic string
     const subdir = rootURL.pathname.replace(/\/$/, '');
-
     const replacementRegex = new RegExp(escapeRegExp(options.replacementStr), 'g');
-
     return str.replace(replacementRegex, subdir);
 };
-
-module.exports = transformReadyToRelative;
+exports.default = transformReadyToRelative;

package/lib/utils/types.d.ts

@@ -0,0 +1,92 @@
+export type UnknownRecord = Record<string, unknown>;
+export interface AssetAwareOptions extends UnknownRecord {
+    assetsOnly: boolean;
+    staticImageUrlPrefix?: string;
+}
+export type AssetAwareOptionsInput = Partial<AssetAwareOptions>;
+export interface SecureOptions extends AssetAwareOptions {
+    secure?: boolean;
+}
+export type SecureOptionsInput = Partial<SecureOptions>;
+export interface TransformReadyReplacementOptions extends UnknownRecord {
+    replacementStr: string;
+    withoutSubdirectory?: boolean;
+}
+export type TransformReadyReplacementOptionsInput = Partial<TransformReadyReplacementOptions>;
+export interface BaseUrlOptions extends UnknownRecord {
+    imageBaseUrl?: string | null;
+    filesBaseUrl?: string | null;
+    mediaBaseUrl?: string | null;
+}
+export type BaseUrlOptionsInput = Partial<BaseUrlOptions>;
+export interface EarlyExitOptions extends UnknownRecord {
+    earlyExitMatchStr?: string;
+}
+export type EarlyExitOptionsInput = Partial<EarlyExitOptions>;
+export interface AbsoluteToTransformReadyOptions extends TransformReadyReplacementOptions, BaseUrlOptions, AssetAwareOptions {
+    staticFilesUrlPrefix?: string;
+    staticMediaUrlPrefix?: string;
+}
+export type AbsoluteToTransformReadyOptionsInput = Partial<AbsoluteToTransformReadyOptions>;
+export type UrlTransformFunction = (url: string, siteUrl: string, itemPath: string | null, options: UnknownRecord) => string;
+export type TransformType = 'relativeToAbsolute' | 'absoluteToRelative' | 'toTransformReady';
+export interface HtmlTransformOptions extends SecureOptions {
+    earlyExitMatchStr?: string;
+}
+export type HtmlTransformOptionsInput = SecureOptionsInput & {
+    earlyExitMatchStr?: string;
+};
+export interface MarkdownTransformOptions extends AssetAwareOptions {
+    ignoreProtocol: boolean;
+    earlyExitMatchStr?: string;
+}
+export type MarkdownTransformOptionsInput = AssetAwareOptionsInput & {
+    ignoreProtocol?: boolean;
+    earlyExitMatchStr?: string;
+};
+export interface MarkdownTransformFunctions {
+    html: UrlTransformFunction;
+    url: UrlTransformFunction;
+}
+export type CardTransformer = (payload: unknown, options: UnknownRecord) => unknown;
+export interface MobiledocCardTransformer {
+    name: string;
+    relativeToAbsolute?: CardTransformer;
+    absoluteToRelative?: CardTransformer;
+    toTransformReady?: CardTransformer;
+}
+export interface MobiledocTransformOptions extends SecureOptions {
+    cardTransformers: MobiledocCardTransformer[];
+    siteUrl: string;
+    itemPath: string | null;
+    transformType: TransformType;
+}
+export type MobiledocTransformOptionsInput = Partial<Omit<MobiledocTransformOptions, 'cardTransformers' | 'siteUrl' | 'itemPath' | 'transformType'>> & {
+    cardTransformers?: MobiledocCardTransformer[];
+    siteUrl?: string;
+    itemPath?: string | null;
+    transformType?: TransformType;
+};
+export type LexicalTransformFunction = (value: string) => string;
+export interface LexicalUrlTransformMap {
+    [key: string]: string | LexicalUrlTransformMap;
+}
+export interface LexicalNodeConfig {
+    getType(): string;
+    urlTransformMap?: LexicalUrlTransformMap;
+}
+export type LexicalTransformRegistry = Partial<Record<TransformType, Record<string, LexicalTransformFunction>>>;
+export interface LexicalTransformOptions extends SecureOptions {
+    nodes: LexicalNodeConfig[];
+    transformMap: LexicalTransformRegistry;
+    transformType: TransformType;
+    siteUrl: string;
+    itemPath: string | null;
+}
+export type LexicalTransformOptionsInput = Partial<Omit<LexicalTransformOptions, 'nodes' | 'transformMap' | 'siteUrl' | 'itemPath' | 'transformType'>> & {
+    nodes?: LexicalNodeConfig[];
+    transformMap?: LexicalTransformRegistry;
+    siteUrl?: string;
+    itemPath?: string | null;
+    transformType?: TransformType;
+};

package/lib/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/url-join.d.ts

@@ -0,0 +1,12 @@
+interface UrlJoinOptions {
+    rootUrl: string;
+}
+/** urlJoin
+* Returns a URL/path for internal use in Ghost.
+* @param {string[]} parts takes parts and concats those to a valid path/URL.
+* @param {Object} options
+* @param {string} options.rootUrl used for deduplicating any subdirectories
+* @return {string} URL concatinated URL/path of arguments.
+*/
+declare function urlJoin(parts: string[], options?: UrlJoinOptions): string;
+export default urlJoin;

package/lib/utils/url-join.js

@@ -1,5 +1,9 @@
-const deduplicateSubdirectory = require('./deduplicate-subdirectory');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deduplicate_subdirectory_1 = __importDefault(require("./deduplicate-subdirectory"));
 /** urlJoin
 * Returns a URL/path for internal use in Ghost.
 * @param {string[]} parts takes parts and concats those to a valid path/URL.
@@ -7,31 +11,27 @@ const deduplicateSubdirectory = require('./deduplicate-subdirectory');
 * @param {string} options.rootUrl used for deduplicating any subdirectories
 * @return {string} URL concatinated URL/path of arguments.
 */
-function urlJoin(parts, options) {
+function urlJoin(parts, options = { rootUrl: '' }) {
     let prefixDoubleSlash = false;
-
     // Remove empty item at the beginning
     if (parts[0] === '') {
         parts.shift();
     }
-
     // Handle schemeless protocols
     if (parts[0].indexOf('//') === 0) {
         prefixDoubleSlash = true;
     }
-
     // join the elements using a slash
     let url = parts.join('/');
-
     // Fix multiple slashes
     url = url.replace(/(^|[^:])\/\/+/g, '$1/');
-
     // Put the double slash back at the beginning if this was a schemeless protocol
     if (prefixDoubleSlash) {
         url = url.replace(/^\//, '//');
     }
-
-    return deduplicateSubdirectory(url, options.rootUrl);
+    if (!options.rootUrl) {
+        return url;
+    }
+    return (0, deduplicate_subdirectory_1.default)(url, options.rootUrl);
 }
-
-module.exports = urlJoin;
+exports.default = urlJoin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/url-utils",
-  "version": "5.0.0-rc.1",
+  "version": "5.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TryGhost/SDK.git",
@@ -8,35 +8,43 @@
   },
   "author": "Ghost Foundation",
   "license": "MIT",
-  "main": "index.js",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
     "dev": "echo \"Implement me!\"",
-    "test": "NODE_ENV=testing c8 --all --reporter text --reporter cobertura --reporter html mocha './test/**/*.test.js'",
-    "lint": "eslint . --ext .js --cache",
+    "pretest": "yarn build",
+    "test": "NODE_ENV=testing c8 --src lib --all --reporter text --reporter cobertura --reporter html mocha './test/**/*.test.js'",
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint src test --ext .js,.ts --cache",
+    "prepare": "NODE_ENV=production yarn build",
     "posttest": "yarn lint"
   },
   "files": [
-    "lib/",
-    "index.js"
+    "lib/"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@tryghost/config-url-helpers": "^1.0.17",
+    "@tryghost/config-url-helpers": "^1.0.19",
+    "@types/cheerio": "^0.22.31",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.0.0",
     "c8": "10.1.3",
-    "mocha": "11.7.4",
+    "mocha": "11.7.5",
     "rewire": "9.0.1",
     "should": "13.2.3",
-    "sinon": "21.0.0"
+    "sinon": "21.0.0",
+    "typescript": "5.9.3"
   },
   "dependencies": {
     "cheerio": "^0.22.0",
     "lodash": "^4.17.21",
     "moment": "^2.27.0",
     "moment-timezone": "^0.5.31",
-    "remark": "^11.0.2",
-    "remark-footnotes": "^1.0.0",
+    "remark": "11.0.2",
+    "remark-footnotes": "1.0.0",
     "unist-util-visit": "^2.0.0"
-  }
+  },
+  "gitHead": "a97d783ddb64ae80592ec03468b221a4ec37948a"
 }

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/UrlUtils');