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

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

@@ -1,12 +1,12 @@
+"use strict";
+// @ts-nocheck
 const relativeToTransformReady = require('./relative-to-transform-ready');
-
 const plaintextRelativeToTransformReady = function plaintextRelativeToTransformReady(plaintext, rootUrl, itemPath, options) {
     // itemPath is optional, if it's an object may be the options param instead
     if (typeof itemPath === 'object' && !options) {
         options = itemPath;
         itemPath = null;
     }
-
     // plaintext links look like "Link title [url]"
     // those are all we care about so we can do a fast regex here
     return plaintext.replace(/ \[(\/.*?)\]/g, function (fullMatch, path) {
@@ -14,5 +14,4 @@ const plaintextRelativeToTransformReady = function plaintextRelativeToTransformR
         return ` [${newPath}]`;
     });
 };
-
 module.exports = plaintextRelativeToTransformReady;

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

@@ -0,0 +1,3 @@
+declare const plaintextRelativeToTransformReady: any;
+declare const plaintextAbsoluteToTransformReady: any;
+declare function plaintextToTransformReady(plaintext: any, siteUrl: any, itemPath: any, options: any): any;

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

@@ -1,6 +1,7 @@
+"use strict";
+// @ts-nocheck
 const plaintextRelativeToTransformReady = require('./plaintext-relative-to-transform-ready');
 const plaintextAbsoluteToTransformReady = require('./plaintext-absolute-to-transform-ready');
-
 function plaintextToTransformReady(plaintext, siteUrl, itemPath, options) {
     if (typeof itemPath === 'object' && !options) {
         options = itemPath;
@@ -9,5 +10,4 @@ function plaintextToTransformReady(plaintext, siteUrl, itemPath, options) {
     const relativeTransformed = plaintextRelativeToTransformReady(plaintext, siteUrl, itemPath, options);
     return plaintextAbsoluteToTransformReady(relativeTransformed, siteUrl, options);
 }
-
 module.exports = plaintextToTransformReady;

package/lib/utils/relative-to-absolute.d.ts

@@ -0,0 +1,13 @@
+declare const URL: any;
+declare const urlJoin: any;
+/**
+ * Convert a root-relative path to an absolute URL based on the supplied root.
+ * Will _only_ convert root-relative urls (/some/path not some/path)
+ *
+ * @param {string} path
+ * @param {string} rootUrl
+ * @param {string} itemPath
+ * @param {object} options
+ * @returns {string} The passed in url or an absolute URL using
+ */
+declare const relativeToAbsolute: (path: any, rootUrl: any, itemPath: any, _options: any) => any;

package/lib/utils/relative-to-absolute.js

@@ -1,7 +1,8 @@
+"use strict";
+// @ts-nocheck
 // require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
+const { URL } = require('url');
 const urlJoin = require('./url-join');
-
 // NOTE: Ghost's relative->absolute handling is a little strange when the rootUrl
 // includes a subdirectory. Root-relative paths such as /content/image.jpg are
 // actually treated as subdirectory-relative. This means that it's possible to
@@ -10,7 +11,6 @@ const urlJoin = require('./url-join');
 // of path styles (/content/image.png and /subdir/content/image.png). To handle
 // this when all root-relative paths are treated as subdir-relative we have to
 // rely on subdirectory deduplication.
-
 /**
  * Convert a root-relative path to an absolute URL based on the supplied root.
  * Will _only_ convert root-relative urls (/some/path not some/path)
@@ -27,19 +27,16 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
         _options = itemPath;
         itemPath = null;
     }
-
     // itemPath could be sent as a full url in which case, extract the pathname
     if (itemPath && itemPath.match(/^http/)) {
         const itemUrl = new URL(itemPath);
         itemPath = itemUrl.pathname;
     }
-
     const defaultOptions = {
         assetsOnly: false,
         staticImageUrlPrefix: 'content/images'
     };
     const options = Object.assign({}, defaultOptions, _options);
-
     // return the path as-is if it's not an asset path and we're only modifying assets
     if (options.assetsOnly) {
         const staticImageUrlPrefixRegex = new RegExp(options.staticImageUrlPrefix);
@@ -47,48 +44,39 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
             return path;
         }
     }
-
     // if URL is absolute return it as-is
     try {
         const parsed = new URL(path, 'http://relative');
-
         if (parsed.origin !== 'http://relative') {
             return path;
         }
-
         // Do not convert protocol relative URLs
         if (path.lastIndexOf('//', 0) === 0) {
             return path;
         }
-    } catch (e) {
+    }
+    catch (e) {
         return path;
     }
-
     // return the path as-is if it's a pure hash param
     if (path.startsWith('#')) {
         return path;
     }
-
     // return the path as-is if it's not root-relative and we have no itemPath
     if (!itemPath && !path.match(/^\//)) {
         return path;
     }
-
     // force root to always have a trailing-slash for consistent behaviour
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-
     const parsedRootUrl = new URL(rootUrl);
     const basePath = path.startsWith('/') ? '' : itemPath;
-    const fullPath = urlJoin([parsedRootUrl.pathname, basePath, path], {rootUrl});
+    const fullPath = urlJoin([parsedRootUrl.pathname, basePath, path], { rootUrl });
     const absoluteUrl = new URL(fullPath, rootUrl);
-
     if (options.secure) {
         absoluteUrl.protocol = 'https:';
     }
-
     return absoluteUrl.toString();
 };
-
 module.exports = relativeToAbsolute;

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

@@ -0,0 +1,2 @@
+declare const relativeToAbsolute: any;
+declare const relativeToTransformReady: (url: any, root: any, itemPath: any, _options: any) => any;

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

@@ -1,12 +1,12 @@
+"use strict";
+// @ts-nocheck
 const relativeToAbsolute = require('./relative-to-absolute');
-
 const relativeToTransformReady = function (url, root, itemPath, _options) {
     // itemPath is optional, if it's an object may be the options param instead
     if (typeof itemPath === 'object' && !_options) {
         _options = itemPath;
         itemPath = null;
     }
-
     const defaultOptions = {
         replacementStr: '__GHOST_URL__',
         staticImageUrlPrefix: 'content/images'
@@ -15,28 +15,21 @@ const relativeToTransformReady = function (url, root, itemPath, _options) {
         secure: false
     };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
     // convert to absolute
     const absoluteUrl = relativeToAbsolute(url, root, itemPath, options);
-
     if (absoluteUrl === url) {
         return url;
     }
-
     const rootUrl = new URL(root);
     const rootPathname = rootUrl.pathname.replace(/\/$/, '');
-
     // only convert to transform-ready if root url has no subdirectory or the subdirectory matches
     if (!url.match(/^\//) || rootPathname === '' || url.indexOf(rootPathname) === 0 || url.indexOf(`/${options.staticImageUrlPrefix}`) === 0) {
         // replace root with replacement string
         const transformedUrl = absoluteUrl
             .replace(root, `${options.replacementStr}/`) // always have trailing slash after magic string
             .replace(/([^:])\/\//g, '$1/');
-
         return transformedUrl;
     }
-
     return url;
 };
-
 module.exports = relativeToTransformReady;

package/lib/utils/replace-permalink.d.ts

@@ -0,0 +1,5 @@
+declare const moment: any;
+/**
+ * creates the url path for a post based on blog timezone and permalink pattern
+ */
+declare function replacePermalink(permalink: any, resource: any, timezone?: string): any;

package/lib/utils/replace-permalink.js

@@ -1,5 +1,6 @@
+"use strict";
+// @ts-nocheck
 const moment = require('moment-timezone');
-
 /**
  * creates the url path for a post based on blog timezone and permalink pattern
  */
@@ -33,7 +34,6 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return resource.id;
         }
     };
-
     // replace tags like :slug or :year with actual values
     const permalinkKeys = Object.keys(permalinkLookUp);
     return output.replace(/(:[a-z_]+)/g, function (match) {
@@ -42,5 +42,4 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
         }
     });
 }
-
 module.exports = replacePermalink;

package/lib/utils/strip-subdirectory-from-path.d.ts

@@ -0,0 +1,9 @@
+declare const URL: any;
+/**
+ * Removes the directory in the root url from the relative path
+ *
+ * @param {string} path Relative path (eg, '/my/subdir/my/file.png)
+ * @param {string} rootUrl Root URL (eg, 'https://mysite.com/my/subdir/)
+ * @returns {string} Path relative to the rootUrl's path
+ */
+declare const stripSubdirectoryFromPath: (path?: string, rootUrl?: string) => string;

package/lib/utils/strip-subdirectory-from-path.js

@@ -1,5 +1,6 @@
-const {URL} = require('url');
-
+"use strict";
+// @ts-nocheck
+const { URL } = require('url');
 /**
  * Removes the directory in the root url from the relative path
  *
@@ -12,25 +13,20 @@ const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '',
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-
     let parsedRoot;
-
     try {
         parsedRoot = new URL(rootUrl);
-    } catch (e) {
+    }
+    catch (e) {
         return path;
     }
-
     // do nothing if rootUrl does not have a subdirectory
     if (parsedRoot.pathname === '/') {
         return path;
     }
-
     if (path.startsWith(parsedRoot.pathname)) {
         return path.replace(parsedRoot.pathname, '/');
     }
-
     return path;
 };
-
 module.exports = stripSubdirectoryFromPath;

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

@@ -0,0 +1,3 @@
+declare const relativeToAbsolute: any;
+declare const absoluteToTransformReady: any;
+declare function toTransformReady(url: any, siteUrl: any, itemPath: any, options: any): any;

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

@@ -1,6 +1,7 @@
+"use strict";
+// @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;
@@ -9,5 +10,4 @@ function toTransformReady(url, siteUrl, itemPath, options) {
     const absoluteUrl = relativeToAbsolute(url, siteUrl, itemPath, options);
     return absoluteToTransformReady(absoluteUrl, siteUrl, options);
 }
-
 module.exports = toTransformReady;

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

@@ -0,0 +1 @@
+declare const transformReadyToAbsolute: (str: string | undefined, root: any, _options?: {}) => string;

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

@@ -1,14 +1,8 @@
+"use strict";
+// @ts-nocheck
 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;

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

@@ -0,0 +1 @@
+declare const transformReadyToRelative: (str: string | undefined, root: any, _options?: {}) => string;

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

@@ -1,24 +1,20 @@
+"use strict";
+// @ts-nocheck
 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);
     // 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;

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

@@ -0,0 +1,9 @@
+declare const deduplicateSubdirectory: any;
+/** 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: any, options: any): any;

package/lib/utils/url-join.js

@@ -1,5 +1,6 @@
+"use strict";
+// @ts-nocheck
 const deduplicateSubdirectory = 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.
@@ -9,29 +10,22 @@ const deduplicateSubdirectory = require('./deduplicate-subdirectory');
 */
 function urlJoin(parts, options) {
     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);
 }
-
 module.exports = urlJoin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/url-utils",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TryGhost/SDK.git",
@@ -9,10 +9,14 @@
   "author": "Ghost Foundation",
   "license": "MIT",
   "main": "index.js",
+  "types": "lib/UrlUtils.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 index.js --ext .js,.ts --cache",
+    "prepare": "NODE_ENV=production yarn build",
     "posttest": "yarn lint"
   },
   "files": [
@@ -23,12 +27,16 @@
     "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",
@@ -38,5 +46,6 @@
     "remark": "^11.0.2",
     "remark-footnotes": "^1.0.0",
     "unist-util-visit": "^2.0.0"
-  }
+  },
+  "gitHead": "91913b7a8e8afc3ddc411eceacb3d5b271671bd6"
 }