Added types to transform utilities

vershwal · vershwal · commit d2c67cb592c5 · 2025-11-13T01:52:52.000+05:30
diff --git a/packages/url-utils/src/utils/absolute-to-relative.ts b/packages/url-utils/src/utils/absolute-to-relative.ts
@@ -1,7 +1,13 @@
-// @ts-nocheck
 // require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
-const stripSubdirectoryFromPath = require('./strip-subdirectory-from-path');
+import {URL} from 'url';
+import stripSubdirectoryFromPath from './strip-subdirectory-from-path';
+
+interface AbsoluteToRelativeOptions {
+    ignoreProtocol?: boolean;
+    withoutSubdirectory?: boolean;
+    assetsOnly?: boolean;
+    staticImageUrlPrefix?: string;
+}
 
 /**
  * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
@@ -13,8 +19,8 @@ const stripSubdirectoryFromPath = require('./strip-subdirectory-from-path');
  * @param {boolean} [options.withoutSubdirectory=false] Strip the root subdirectory from the returned path
  * @returns {string} The passed-in url or a relative path
  */
-const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options = {}) {
-    const defaultOptions = {
+const absoluteToRelative = function absoluteToRelative(url: string, rootUrl: string, _options: AbsoluteToRelativeOptions = {}): string {
+    const defaultOptions: Required<AbsoluteToRelativeOptions> = {
         ignoreProtocol: true,
         withoutSubdirectory: false,
         assetsOnly: false,
@@ -29,21 +35,25 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
         }
     }
 
-    let parsedUrl;
-    let parsedRoot;
+    let parsedUrl: URL;
+    let parsedRoot: URL | undefined;
 
     try {
         parsedUrl = new URL(url, 'http://relative');
         parsedRoot = parsedUrl.origin === 'null' ? undefined : new URL(rootUrl || parsedUrl.origin);
 
         // return the url as-is if it was relative or non-http
-        if (parsedUrl.origin === 'null' || parsedUrl.origin === 'http://relative') {
+        if (parsedUrl.origin === 'null' || parsedUrl.origin === 'http://relative' || !parsedRoot) {
             return url;
         }
     } catch (e) {
         return url;
     }
 
+    if (!parsedRoot) {
+        return url;
+    }
+
     const matchesHost = parsedUrl.host === parsedRoot.host;
     const matchesProtocol = parsedUrl.protocol === parsedRoot.protocol;
     const matchesPath = parsedUrl.pathname.indexOf(parsedRoot.pathname) === 0;
@@ -61,4 +71,5 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
     return url;
 };
 
+export default absoluteToRelative;
 module.exports = absoluteToRelative;
diff --git a/packages/url-utils/src/utils/absolute-to-transform-ready.ts b/packages/url-utils/src/utils/absolute-to-transform-ready.ts
@@ -1,8 +1,12 @@
-// @ts-nocheck
-const absoluteToRelative = require('./absolute-to-relative');
+import absoluteToRelative from './absolute-to-relative';
 
-const absoluteToTransformReady = function (url, root, _options) {
-    const defaultOptions = {
+interface AbsoluteToTransformReadyOptions {
+    replacementStr?: string;
+    withoutSubdirectory?: boolean;
+}
+
+const absoluteToTransformReady = function (url: string, root: string, _options: AbsoluteToTransformReadyOptions = {}): string {
+    const defaultOptions: Required<AbsoluteToTransformReadyOptions> = {
         replacementStr: '__GHOST_URL__',
         withoutSubdirectory: true
     };
@@ -37,4 +41,5 @@ const absoluteToTransformReady = function (url, root, _options) {
     return `${options.replacementStr}${relativeUrl}`;
 };
 
+export default absoluteToTransformReady;
 module.exports = absoluteToTransformReady;
diff --git a/packages/url-utils/src/utils/index.ts b/packages/url-utils/src/utils/index.ts
@@ -5,10 +5,17 @@ import isSSL from './is-ssl';
 import replacePermalink from './replace-permalink';
 import stripSubdirectoryFromPath from './strip-subdirectory-from-path';
 import urlJoin from './url-join';
+import absoluteToRelative from './absolute-to-relative';
+import absoluteToTransformReady from './absolute-to-transform-ready';
+import relativeToAbsolute from './relative-to-absolute';
+import relativeToTransformReady from './relative-to-transform-ready';
+import toTransformReady from './to-transform-ready';
+import transformReadyToAbsolute from './transform-ready-to-absolute';
+import transformReadyToRelative from './transform-ready-to-relative';
 
 module.exports = {
-    absoluteToRelative: require('./absolute-to-relative'),
-    absoluteToTransformReady: require('./absolute-to-transform-ready'),
+    absoluteToRelative,
+    absoluteToTransformReady,
     deduplicateDoubleSlashes,
     deduplicateSubdirectory,
     htmlAbsoluteToRelative: require('./html-absolute-to-relative'),
@@ -35,12 +42,12 @@ module.exports = {
     plaintextAbsoluteToTransformReady: require('./plaintext-absolute-to-transform-ready'),
     plaintextRelativeToTransformReady: require('./plaintext-relative-to-transform-ready'),
     plaintextToTransformReady: require('./plaintext-to-transform-ready'),
-    relativeToAbsolute: require('./relative-to-absolute'),
-    relativeToTransformReady: require('./relative-to-transform-ready'),
+    relativeToAbsolute,
+    relativeToTransformReady,
     replacePermalink,
     stripSubdirectoryFromPath,
-    toTransformReady: require('./to-transform-ready'),
-    transformReadyToAbsolute: require('./transform-ready-to-absolute'),
-    transformReadyToRelative: require('./transform-ready-to-relative'),
+    toTransformReady,
+    transformReadyToAbsolute,
+    transformReadyToRelative,
     urlJoin
 };
diff --git a/packages/url-utils/src/utils/relative-to-transform-ready.ts b/packages/url-utils/src/utils/relative-to-transform-ready.ts
@@ -1,24 +1,42 @@
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
-
-const relativeToTransformReady = function (url, root, itemPath, _options) {
+import {URL} from 'url';
+import relativeToAbsolute from './relative-to-absolute';
+
+interface RelativeToTransformReadyOptions {
+    replacementStr?: string;
+    staticImageUrlPrefix?: string;
+    secure?: boolean;
+}
+
+const relativeToTransformReady = function (
+    url: string,
+    root: string,
+    itemPath?: string | RelativeToTransformReadyOptions | null,
+    _options?: RelativeToTransformReadyOptions
+): string {
     // itemPath is optional, if it's an object may be the options param instead
-    if (typeof itemPath === 'object' && !_options) {
-        _options = itemPath;
-        itemPath = null;
+    let actualItemPath: string | null = null;
+    let actualOptions: RelativeToTransformReadyOptions;
+
+    if (itemPath && typeof itemPath === 'object' && !_options) {
+        actualOptions = itemPath;
+        actualItemPath = null;
+    } else {
+        actualOptions = _options || {};
+        actualItemPath = typeof itemPath === 'string' ? itemPath : null;
     }
 
-    const defaultOptions = {
+    const defaultOptions: Required<RelativeToTransformReadyOptions> = {
         replacementStr: '__GHOST_URL__',
-        staticImageUrlPrefix: 'content/images'
+        staticImageUrlPrefix: 'content/images',
+        secure: false
     };
     const overrideOptions = {
         secure: false
     };
-    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+    const options = Object.assign({}, defaultOptions, actualOptions, overrideOptions);
 
     // convert to absolute
-    const absoluteUrl = relativeToAbsolute(url, root, itemPath, options);
+    const absoluteUrl = relativeToAbsolute(url, root, actualItemPath, options);
 
     if (absoluteUrl === url) {
         return url;
@@ -40,4 +58,5 @@ const relativeToTransformReady = function (url, root, itemPath, _options) {
     return url;
 };
 
+export default relativeToTransformReady;
 module.exports = relativeToTransformReady;
diff --git a/packages/url-utils/src/utils/to-transform-ready.ts b/packages/url-utils/src/utils/to-transform-ready.ts
@@ -1,14 +1,33 @@
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-
-function toTransformReady(url, siteUrl, itemPath, options) {
-    if (typeof itemPath === 'object' && !options) {
-        options = itemPath;
-        itemPath = null;
+import relativeToAbsolute from './relative-to-absolute';
+import absoluteToTransformReady from './absolute-to-transform-ready';
+
+interface ToTransformReadyOptions {
+    replacementStr?: string;
+    withoutSubdirectory?: boolean;
+    assetsOnly?: boolean;
+    staticImageUrlPrefix?: string;
+    secure?: boolean;
+}
+
+function toTransformReady(
+    url: string,
+    siteUrl: string,
+    itemPath?: string | ToTransformReadyOptions | null,
+    options?: ToTransformReadyOptions
+): string {
+    let actualItemPath: string | null = null;
+    let actualOptions: ToTransformReadyOptions;
+
+    if (itemPath && typeof itemPath === 'object' && !options) {
+        actualOptions = itemPath;
+        actualItemPath = null;
+    } else {
+        actualOptions = options || {};
+        actualItemPath = typeof itemPath === 'string' ? itemPath : null;
     }
-    const absoluteUrl = relativeToAbsolute(url, siteUrl, itemPath, options);
-    return absoluteToTransformReady(absoluteUrl, siteUrl, options);
+    const absoluteUrl = relativeToAbsolute(url, siteUrl, actualItemPath, actualOptions);
+    return absoluteToTransformReady(absoluteUrl, siteUrl, actualOptions);
 }
 
+export default toTransformReady;
 module.exports = toTransformReady;
diff --git a/packages/url-utils/src/utils/transform-ready-to-absolute.ts b/packages/url-utils/src/utils/transform-ready-to-absolute.ts
@@ -1,10 +1,13 @@
-// @ts-nocheck
-function escapeRegExp(string) {
+function escapeRegExp(string: string): string {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-const transformReadyToAbsolute = function (str = '', root, _options = {}) {
-    const defaultOptions = {
+interface TransformReadyToAbsoluteOptions {
+    replacementStr?: string;
+}
+
+const transformReadyToAbsolute = function (str: string = '', root: string, _options: TransformReadyToAbsoluteOptions = {}): string {
+    const defaultOptions: Required<TransformReadyToAbsoluteOptions> = {
         replacementStr: '__GHOST_URL__'
     };
     const options = Object.assign({}, defaultOptions, _options);
@@ -18,4 +21,5 @@ const transformReadyToAbsolute = function (str = '', root, _options = {}) {
     return str.replace(replacementRegex, root.replace(/\/$/, ''));
 };
 
+export default transformReadyToAbsolute;
 module.exports = transformReadyToAbsolute;
diff --git a/packages/url-utils/src/utils/transform-ready-to-relative.ts b/packages/url-utils/src/utils/transform-ready-to-relative.ts
@@ -1,10 +1,15 @@
-// @ts-nocheck
-function escapeRegExp(string) {
+import {URL} from 'url';
+
+function escapeRegExp(string: string): string {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-const transformReadyToRelative = function (str = '', root, _options = {}) {
-    const defaultOptions = {
+interface TransformReadyToRelativeOptions {
+    replacementStr?: string;
+}
+
+const transformReadyToRelative = function (str: string = '', root: string, _options: TransformReadyToRelativeOptions = {}): string {
+    const defaultOptions: Required<TransformReadyToRelativeOptions> = {
         replacementStr: '__GHOST_URL__'
     };
     const options = Object.assign({}, defaultOptions, _options);
@@ -22,4 +27,5 @@ const transformReadyToRelative = function (str = '', root, _options = {}) {
     return str.replace(replacementRegex, subdir);
 };
 
+export default transformReadyToRelative;
 module.exports = transformReadyToRelative;
