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

package/index.js

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

package/lib/UrlUtils.d.ts

@@ -0,0 +1,3 @@
+declare const _: any;
+declare const utils: any;
+declare function assignOptions(target: any, ...sources: any[]): any;

package/lib/UrlUtils.js

@@ -1,25 +1,8 @@
+"use strict";
+// @ts-nocheck
 // Contains all path information to be used throughout the codebase.
 const _ = require('lodash');
 const utils = require('./utils');
-
-const STATIC_IMAGE_URL_PREFIX = 'content/images';
-const STATIC_FILES_URL_PREFIX = 'content/files';
-const STATIC_MEDIA_URL_PREFIX = 'content/media';
-
-/**
- * @typedef {Object} AssetBaseUrls
- * @property {string} [image] Absolute base URL for images
- * @property {string} [files] Absolute base URL for files
- * @property {string} [media] Absolute base URL for media
- */
-
-function trimTrailingSlash(url) {
-    if (!url) {
-        return url;
-    }
-    return url.replace(/\/+$/, '');
-}
-
 // similar to Object.assign but will not override defaults if a source value is undefined
 function assignOptions(target, ...sources) {
     const options = sources.map((x) => {
@@ -40,68 +23,65 @@ module.exports = class UrlUtils {
     * @param {('content' | 'admin')} [options.defaultApiType='content'] default API type to be used
      * @param {Object} [options.slugs] object with 2 properties reserved and protected containing arrays of special case slugs
      * @param {Number} [options.redirectCacheMaxAge]
-     * @param {AssetBaseUrls} [options.assetBaseUrls] asset CDN base URLs
-    */
+     * @param {String} [options.staticImageUrlPrefix='content/images'] static prefix for serving images. Should not be passed in, unless customizing ghost instance image storage
+     * @param {String} [options.staticFilesUrlPrefix='content/files'] static prefix for serving files. Should not be passed in, unless customizing ghost instance file storage
+     * @param {String} [options.staticMediaUrlPrefix='content/media'] static prefix for serving media. Should not be passed in, unless customizing ghost instance media storage
+     * @param {object} [options.assetBaseUrls] asset CDN base URLs
+     * @param {string} [options.assetBaseUrls.image] image asset CDN base URL
+     * @param {string} [options.assetBaseUrls.files] files asset CDN base URL
+     * @param {string} [options.assetBaseUrls.media] media asset CDN base URL
+     */
     constructor(options = {}) {
         const defaultOptions = {
             slugs: null,
             redirectCacheMaxAge: null,
             baseApiPath: '/ghost/api',
-            defaultApiType: 'content'
+            defaultApiType: 'content',
+            staticImageUrlPrefix: 'content/images',
+            staticFilesUrlPrefix: 'content/files',
+            staticMediaUrlPrefix: 'content/media'
         };
-
         this._config = assignOptions({}, defaultOptions, options);
-        this._config.staticImageUrlPrefix = STATIC_IMAGE_URL_PREFIX;
-        this._config.staticFilesUrlPrefix = STATIC_FILES_URL_PREFIX;
-        this._config.staticMediaUrlPrefix = STATIC_MEDIA_URL_PREFIX;
-
         const assetBaseUrls = options.assetBaseUrls || {};
         this._assetBaseUrls = {
-            image: trimTrailingSlash(assetBaseUrls.image || null),
-            files: trimTrailingSlash(assetBaseUrls.files || null),
-            media: trimTrailingSlash(assetBaseUrls.media || null)
+            image: assetBaseUrls.image || null,
+            files: assetBaseUrls.files || null,
+            media: assetBaseUrls.media || null
         };
-
         this.getSubdir = options.getSubdir;
         this.getSiteUrl = options.getSiteUrl;
         this.getAdminUrl = options.getAdminUrl;
     }
-
     _assetOptionDefaults() {
-        const siteBase = trimTrailingSlash(this.getSiteUrl ? this.getSiteUrl() : null);
         return {
             staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             staticFilesUrlPrefix: this._config.staticFilesUrlPrefix,
             staticMediaUrlPrefix: this._config.staticMediaUrlPrefix,
-            imageBaseUrl: this._assetBaseUrls.image || siteBase,
+            imageBaseUrl: this._assetBaseUrls.image || null,
             filesBaseUrl: this._assetBaseUrls.files || null,
             mediaBaseUrl: this._assetBaseUrls.media || null
         };
     }
-
     _buildAssetOptions(additionalDefaults = {}, options) {
         return assignOptions({}, this._assetOptionDefaults(), additionalDefaults, options || {});
     }
-
     getProtectedSlugs() {
         let subDir = this.getSubdir();
-
         if (!_.isEmpty(subDir)) {
             return this._config.slugs.concat([subDir.split('/').pop()]);
-        } else {
+        }
+        else {
             return this._config.slugs;
         }
     }
-
     /** urlJoin
      * Returns a URL/path for internal use in Ghost.
      * @param {string} arguments takes arguments and concats those to a valid path/URL.
      * @return {string} URL concatinated URL/path of arguments.
      */
     urlJoin(...parts) {
-        return utils.urlJoin(parts, {rootUrl: this.getSiteUrl()});
+        return utils.urlJoin(parts, { rootUrl: this.getSiteUrl() });
     }
-
     // ## createUrl
     // Simple url creation from a given path
     // Ensures that our urls contain the subdirectory if there is one
@@ -117,23 +97,20 @@ module.exports = class UrlUtils {
     //  - a URL which always ends with a slash
     createUrl(urlPath = '/', absolute = false, trailingSlash) {
         let base;
-
         // create base of url, always ends without a slash
         if (absolute) {
             base = this.getSiteUrl();
-        } else {
+        }
+        else {
             base = this.getSubdir();
         }
-
         if (trailingSlash) {
             if (!urlPath.match(/\/$/)) {
                 urlPath += '/';
             }
         }
-
         return this.urlJoin(base, urlPath);
     }
-
     // ## urlFor
     // Synchronous url creation for a given context
     // Can generate a url for a named path and given path.
@@ -155,40 +132,36 @@ module.exports = class UrlUtils {
         let knownObjects = ['image', 'nav'];
         let baseUrl;
         let hostname;
-
         // this will become really big
         let knownPaths = {
             home: '/',
             sitemap_xsl: '/sitemap.xsl'
         };
-
         // Make data properly optional
         if (_.isBoolean(data)) {
             absolute = data;
             data = null;
         }
-
         if (_.isObject(context) && context.relativeUrl) {
             urlPath = context.relativeUrl;
-        } else if (_.isString(context) && _.indexOf(knownObjects, context) !== -1) {
+        }
+        else if (_.isString(context) && _.indexOf(knownObjects, context) !== -1) {
             if (context === 'image' && data.image) {
                 urlPath = data.image;
                 imagePathRe = new RegExp('^' + this.getSubdir() + '/' + this._config.staticImageUrlPrefix);
                 absolute = imagePathRe.test(data.image) ? absolute : false;
-
                 if (absolute) {
                     // Remove the sub-directory from the URL because ghostConfig will add it back.
                     urlPath = urlPath.replace(new RegExp('^' + this.getSubdir()), '');
                     baseUrl = this.getSiteUrl().replace(/\/$/, '');
                     urlPath = baseUrl + urlPath;
                 }
-
                 return urlPath;
-            } else if (context === 'nav' && data.nav) {
+            }
+            else if (context === 'nav' && data.nav) {
                 urlPath = data.nav.url;
                 baseUrl = this.getSiteUrl();
                 hostname = baseUrl.split('//')[1];
-
                 // If the hostname is present in the url
                 if (urlPath.indexOf(hostname) > -1
                     // do no not apply, if there is a subdomain, or a mailto link
@@ -201,77 +174,71 @@ module.exports = class UrlUtils {
                     absolute = true;
                 }
             }
-        } else if (context === 'home' && absolute) {
+        }
+        else if (context === 'home' && absolute) {
             urlPath = this.getSiteUrl();
-
             // CASE: there are cases where urlFor('home') needs to be returned without trailing
             // slash e. g. the `{{@site.url}}` helper. See https://github.com/TryGhost/Ghost/issues/8569
             if (data && data.trailingSlash === false) {
                 urlPath = urlPath.replace(/\/$/, '');
             }
-        } else if (context === 'admin') {
+        }
+        else if (context === 'admin') {
             let adminUrl = this.getAdminUrl() || this.getSiteUrl();
             let adminPath = '/ghost/';
-
             if (absolute) {
                 urlPath = this.urlJoin(adminUrl, adminPath);
-            } else {
+            }
+            else {
                 urlPath = adminPath;
             }
-        } else if (context === 'api') {
+        }
+        else if (context === 'api') {
             let adminUrl = this.getAdminUrl() || this.getSiteUrl();
             let apiPath = this._config.baseApiPath + '/';
-
             if (data.type && ['admin', 'content'].includes(data.type)) {
                 apiPath += data.type;
-            } else {
+            }
+            else {
                 apiPath += this._config.defaultApiType;
             }
-
             // Ensure we end with a trailing slash
             apiPath += '/';
-
             if (absolute) {
                 urlPath = this.urlJoin(adminUrl, apiPath);
-            } else {
+            }
+            else {
                 urlPath = apiPath;
             }
-        } else if (_.isString(context) && _.indexOf(_.keys(knownPaths), context) !== -1) {
+        }
+        else if (_.isString(context) && _.indexOf(_.keys(knownPaths), context) !== -1) {
             // trying to create a url for a named path
             urlPath = knownPaths[context];
         }
-
         // This url already has a protocol so is likely an external url to be returned
         // or it is an alternative scheme, protocol-less, or an anchor-only path
         if (urlPath && (urlPath.indexOf('://') !== -1 || urlPath.match(/^(\/\/|#|[a-zA-Z0-9-]+:)/))) {
             return urlPath;
         }
-
         return this.createUrl(urlPath, absolute);
     }
-
     redirect301(res, redirectUrl) {
-        res.set({'Cache-Control': 'public, max-age=' + this._config.redirectCacheMaxAge});
+        res.set({ 'Cache-Control': 'public, max-age=' + this._config.redirectCacheMaxAge });
         return res.redirect(301, redirectUrl);
     }
-
     redirectToAdmin(status, res, adminPath) {
         let redirectUrl = this.urlJoin(this.urlFor('admin', true), adminPath, '/');
-
         if (status === 301) {
             return this.redirect301(res, redirectUrl);
         }
         return res.redirect(redirectUrl);
     }
-
     absoluteToRelative(url, options) {
         return utils.absoluteToRelative(url, this.getSiteUrl(), options);
     }
-
     relativeToAbsolute(url, options) {
         return utils.relativeToAbsolute(url, this.getSiteUrl(), options);
     }
-
     toTransformReady(url, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -280,27 +247,22 @@ module.exports = class UrlUtils {
         const _options = this._buildAssetOptions({}, options);
         return utils.toTransformReady(url, this.getSiteUrl(), itemPath, _options);
     }
-
     absoluteToTransformReady(url, options) {
         const _options = this._buildAssetOptions({}, options);
         return utils.absoluteToTransformReady(url, this.getSiteUrl(), _options);
     }
-
     relativeToTransformReady(url, options) {
         const _options = this._buildAssetOptions({}, options);
         return utils.relativeToTransformReady(url, this.getSiteUrl(), _options);
     }
-
     transformReadyToAbsolute(url, options) {
         const _options = this._buildAssetOptions({}, options);
         return utils.transformReadyToAbsolute(url, this.getSiteUrl(), _options);
     }
-
     transformReadyToRelative(url, options) {
         const _options = this._buildAssetOptions({}, options);
         return utils.transformReadyToRelative(url, this.getSiteUrl(), _options);
     }
-
     htmlToTransformReady(html, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -309,7 +271,6 @@ module.exports = class UrlUtils {
         const _options = this._buildAssetOptions({}, options);
         return utils.htmlToTransformReady(html, this.getSiteUrl(), itemPath, _options);
     }
-
     /**
      * Convert relative URLs in html into absolute URLs
      * @param {string} html
@@ -330,7 +291,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.htmlRelativeToAbsolute(html, this.getSiteUrl(), itemPath, _options);
     }
-
     htmlRelativeToTransformReady(html, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -341,21 +301,18 @@ module.exports = class UrlUtils {
         }, options);
         return utils.htmlRelativeToTransformReady(html, this.getSiteUrl(), itemPath, _options);
     }
-
     htmlAbsoluteToRelative(html, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
         return utils.htmlAbsoluteToRelative(html, this.getSiteUrl(), _options);
     }
-
     htmlAbsoluteToTransformReady(html, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
         return utils.htmlAbsoluteToTransformReady(html, this.getSiteUrl(), _options);
     }
-
     markdownToTransformReady(markdown, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -364,7 +321,6 @@ module.exports = class UrlUtils {
         const _options = this._buildAssetOptions({}, options);
         return utils.markdownToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
     }
-
     markdownRelativeToAbsolute(markdown, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -375,7 +331,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.markdownRelativeToAbsolute(markdown, this.getSiteUrl(), itemPath, _options);
     }
-
     markdownRelativeToTransformReady(markdown, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -386,21 +341,18 @@ module.exports = class UrlUtils {
         }, options);
         return utils.markdownRelativeToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
     }
-
     markdownAbsoluteToRelative(markdown, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
         return utils.markdownAbsoluteToRelative(markdown, this.getSiteUrl(), _options);
     }
-
     markdownAbsoluteToTransformReady(markdown, options) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
         return utils.markdownAbsoluteToTransformReady(markdown, this.getSiteUrl(), _options);
     }
-
     mobiledocToTransformReady(serializedMobiledoc, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -411,7 +363,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.mobiledocToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
-
     mobiledocRelativeToAbsolute(serializedMobiledoc, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -423,7 +374,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.mobiledocRelativeToAbsolute(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
-
     mobiledocRelativeToTransformReady(serializedMobiledoc, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -435,7 +385,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.mobiledocRelativeToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
-
     mobiledocAbsoluteToRelative(serializedMobiledoc, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
@@ -443,7 +392,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.mobiledocAbsoluteToRelative(serializedMobiledoc, this.getSiteUrl(), _options);
     }
-
     mobiledocAbsoluteToTransformReady(serializedMobiledoc, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
@@ -451,7 +399,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.mobiledocAbsoluteToTransformReady(serializedMobiledoc, this.getSiteUrl(), _options);
     }
-
     lexicalToTransformReady(serializedLexical, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -462,7 +409,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.lexicalToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
-
     lexicalRelativeToAbsolute(serializedLexical, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -474,7 +420,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.lexicalRelativeToAbsolute(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
-
     lexicalRelativeToTransformReady(serializedLexical, itemPath, options) {
         if (typeof itemPath === 'object' && !options) {
             options = itemPath;
@@ -486,7 +431,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.lexicalRelativeToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
-
     lexicalAbsoluteToRelative(serializedLexical, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
@@ -494,7 +438,6 @@ module.exports = class UrlUtils {
         }, options);
         return utils.lexicalAbsoluteToRelative(serializedLexical, this.getSiteUrl(), _options);
     }
-
     lexicalAbsoluteToTransformReady(serializedLexical, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
@@ -502,12 +445,10 @@ module.exports = class UrlUtils {
         }, options);
         return utils.lexicalAbsoluteToTransformReady(serializedLexical, this.getSiteUrl(), _options);
     }
-
     plaintextToTransformReady(plaintext, options = {}) {
         const _options = this._buildAssetOptions({}, options);
         return utils.plaintextToTransformReady(plaintext, this.getSiteUrl(), _options);
     }
-
     /**
      * Return whether the provided URL is part of the site (checks if same domain and within subdirectory)
      * @param {URL} url
@@ -524,19 +465,15 @@ module.exports = class UrlUtils {
         }
         return false;
     }
-
     get isSSL() {
         return utils.isSSL;
     }
-
     get replacePermalink() {
         return utils.replacePermalink;
     }
-
     get deduplicateDoubleSlashes() {
         return utils.deduplicateDoubleSlashes;
     }
-
     /**
      * If you request **any** image in Ghost, it get's served via
      * http://your-blog.com/content/images/2017/01/02/author.png
@@ -547,17 +484,14 @@ module.exports = class UrlUtils {
      * my-content/another-dir/images/2017/01/02/author.png
      */
     get STATIC_IMAGE_URL_PREFIX() {
-        return STATIC_IMAGE_URL_PREFIX;
+        return this._config.staticImageUrlPrefix;
     }
-
     get STATIC_FILES_URL_PREFIX() {
-        return STATIC_FILES_URL_PREFIX;
+        return this._config.staticFilesUrlPrefix;
     }
-
     get STATIC_MEDIA_URL_PREFIX() {
-        return STATIC_MEDIA_URL_PREFIX;
+        return this._config.staticMediaUrlPrefix;
     }
-
     // expose underlying functions to ease testing
     get _utils() {
         return utils;

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

@@ -0,0 +1,13 @@
+declare const URL: any;
+declare const stripSubdirectoryFromPath: any;
+/**
+ * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
+ *
+ * @param {string} url Absolute URL to convert to relative if possible
+ * @param {string} rootUrl Absolute URL to which the returned relative URL will match the domain root
+ * @param {Object} [options] Options that affect the conversion
+ * @param {boolean} [options.ignoreProtocol=true] Ignore protocol when matching url to root
+ * @param {boolean} [options.withoutSubdirectory=false] Strip the root subdirectory from the returned path
+ * @returns {string} The passed-in url or a relative path
+ */
+declare const absoluteToRelative: (url: any, rootUrl: any, _options?: {}) => any;

package/lib/utils/absolute-to-relative.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 stripSubdirectoryFromPath = require('./strip-subdirectory-from-path');
-
 /**
  * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
  *
@@ -20,44 +21,35 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
         staticImageUrlPrefix: 'content/images'
     };
     const options = Object.assign({}, defaultOptions, _options);
-
     if (options.assetsOnly) {
         const staticImageUrlPrefixRegex = new RegExp(options.staticImageUrlPrefix);
         if (!url.match(staticImageUrlPrefixRegex)) {
             return url;
         }
     }
-
     let parsedUrl;
     let parsedRoot;
-
     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') {
             return url;
         }
-    } catch (e) {
+    }
+    catch (e) {
         return url;
     }
-
     const matchesHost = parsedUrl.host === parsedRoot.host;
     const matchesProtocol = parsedUrl.protocol === parsedRoot.protocol;
     const matchesPath = parsedUrl.pathname.indexOf(parsedRoot.pathname) === 0;
-
     if (matchesHost && (options.ignoreProtocol || matchesProtocol) && matchesPath) {
         let path = parsedUrl.href.replace(parsedUrl.origin, '');
-
         if (options.withoutSubdirectory) {
             path = stripSubdirectoryFromPath(path, rootUrl);
         }
-
         return path;
     }
-
     return url;
 };
-
 module.exports = absoluteToRelative;

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

@@ -0,0 +1,4 @@
+declare const URL: any;
+declare const absoluteToRelative: any;
+declare function isRelative(url: any): boolean;
+declare const absoluteToTransformReady: (url: any, root: any, _options?: {}) => any;