@tryghost/url-utils 4.0.3 → 4.2.0

package/lib/url-utils.js

@@ -427,6 +427,66 @@ module.exports = class UrlUtils {
         return utils.mobiledocAbsoluteToTransformReady(serializedMobiledoc, this.getSiteUrl(), _options);
     }
 
+    lexicalToTransformReady(serializedLexical, itemPath, options) {
+        if (typeof itemPath === 'object' && !options) {
+            options = itemPath;
+            itemPath = null;
+        }
+        const defaultOptions = {
+            cardTransformers: this._config.cardTransformers
+        };
+        const _options = assignOptions({}, defaultOptions, options || {});
+        return utils.lexicalToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
+    }
+
+    lexicalRelativeToAbsolute(serializedLexical, itemPath, options) {
+        if (typeof itemPath === 'object' && !options) {
+            options = itemPath;
+            itemPath = null;
+        }
+        const defaultOptions = {
+            assetsOnly: false,
+            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
+            cardTransformers: this._config.cardTransformers
+        };
+        const _options = assignOptions({}, defaultOptions, options || {});
+        return utils.lexicalRelativeToAbsolute(serializedLexical, this.getSiteUrl(), itemPath, _options);
+    }
+
+    lexicalRelativeToTransformReady(serializedLexical, itemPath, options) {
+        if (typeof itemPath === 'object' && !options) {
+            options = itemPath;
+            itemPath = null;
+        }
+        const defaultOptions = {
+            assetsOnly: false,
+            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
+            cardTransformers: this._config.cardTransformers
+        };
+        const _options = assignOptions({}, defaultOptions, options || {});
+        return utils.lexicalRelativeToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
+    }
+
+    lexicalAbsoluteToRelative(serializedLexical, options = {}) {
+        const defaultOptions = {
+            assetsOnly: false,
+            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
+            cardTransformers: this._config.cardTransformers
+        };
+        const _options = assignOptions({}, defaultOptions, options);
+        return utils.lexicalAbsoluteToRelative(serializedLexical, this.getSiteUrl(), _options);
+    }
+
+    lexicalAbsoluteToTransformReady(serializedLexical, options = {}) {
+        const defaultOptions = {
+            assetsOnly: false,
+            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
+            cardTransformers: this._config.cardTransformers
+        };
+        const _options = assignOptions({}, defaultOptions, options);
+        return utils.lexicalAbsoluteToTransformReady(serializedLexical, this.getSiteUrl(), _options);
+    }
+
     plaintextToTransformReady(plaintext, options = {}) {
         const defaultOptions = {
             staticImageUrlPrefix: this._config.staticImageUrlPrefix
@@ -435,6 +495,23 @@ module.exports = class UrlUtils {
         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
+     * @param {string} [context] describing the context for which you need to check a url
+     * @returns {boolean}
+     */
+    isSiteUrl(url, context = 'home') {
+        const siteUrl = new URL(this.urlFor(context, true));
+        if (siteUrl.host === url.host) {
+            if (url.pathname.startsWith(siteUrl.pathname)) {
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+
     get isSSL() {
         return utils.isSSL;
     }

package/lib/utils/_lexical-transform.js

@@ -0,0 +1,36 @@
+function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPath, _options = {}) {
+    const defaultOptions = {assetsOnly: false, secure: false};
+    const options = Object.assign({}, defaultOptions, _options, {siteUrl, itemPath});
+
+    if (!serializedLexical) {
+        return serializedLexical;
+    }
+
+    // function only accepts serialized lexical so there's no chance of accidentally
+    // modifying pass-by-reference objects
+    const lexical = JSON.parse(serializedLexical);
+
+    if (!lexical?.root?.children) {
+        return serializedLexical;
+    }
+
+    // any lexical links will be a child object with a `url` attribute,
+    // recursively walk the tree transforming any `.url`s
+    const transformChildren = function (children) {
+        for (const child of children) {
+            if (child.url) {
+                child.url = transformFunction(child.url, siteUrl, itemPath, options);
+            }
+
+            if (child.children) {
+                transformChildren(child.children);
+            }
+        }
+    };
+
+    transformChildren(lexical.root.children);
+
+    return JSON.stringify(lexical);
+}
+
+module.exports = lexicalTransform;

package/lib/utils/index.js

@@ -19,6 +19,11 @@ module.exports = {
     mobiledocAbsoluteToTransformReady: require('./mobiledoc-absolute-to-transform-ready'),
     mobiledocRelativeToTransformReady: require('./mobiledoc-relative-to-transform-ready'),
     mobiledocToTransformReady: require('./mobiledoc-to-transform-ready'),
+    lexicalAbsoluteToRelative: require('./lexical-absolute-to-relative'),
+    lexicalRelativeToAbsolute: require('./lexical-relative-to-absolute'),
+    lexicalAbsoluteToTransformReady: require('./lexical-absolute-to-transform-ready'),
+    lexicalRelativeToTransformReady: require('./lexical-relative-to-transform-ready'),
+    lexicalToTransformReady: require('./lexical-to-transform-ready'),
     plaintextAbsoluteToTransformReady: require('./plaintext-absolute-to-transform-ready'),
     plaintextRelativeToTransformReady: require('./plaintext-relative-to-transform-ready'),
     plaintextToTransformReady: require('./plaintext-to-transform-ready'),

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

@@ -0,0 +1,16 @@
+const absoluteToRelative = require('./absolute-to-relative');
+const lexicalTransform = require('./_lexical-transform');
+
+function lexicalAbsoluteToRelative(serializedLexical, siteUrl, _options = {}) {
+    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
+    const overrideOptions = {siteUrl, transformType: 'absoluteToRelative'};
+    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+
+    const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
+        return absoluteToRelative(_url, _siteUrl, __options);
+    };
+
+    return lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
+}
+
+module.exports = lexicalAbsoluteToRelative;

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

@@ -0,0 +1,16 @@
+const absoluteToTransformReady = require('./absolute-to-transform-ready');
+const lexicalTransform = require('./_lexical-transform');
+
+function lexicalAbsoluteToRelative(serializedLexical, siteUrl, _options = {}) {
+    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
+    const overrideOptions = {siteUrl, transformType: 'toTransformReady'};
+    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+
+    const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
+        return absoluteToTransformReady(_url, _siteUrl, __options);
+    };
+
+    return lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
+}
+
+module.exports = lexicalAbsoluteToRelative;

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

@@ -0,0 +1,12 @@
+const relativeToAbsolute = require('./relative-to-absolute');
+const lexicalTransform = require('./_lexical-transform');
+
+function lexicalRelativeToAbsolute(serializedLexical, siteUrl, itemPath, _options = {}) {
+    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
+    const overrideOptions = {siteUrl, itemPath, transformType: 'relativeToAbsolute'};
+    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+
+    return lexicalTransform(serializedLexical, siteUrl, relativeToAbsolute, itemPath, options);
+}
+
+module.exports = lexicalRelativeToAbsolute;

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

@@ -0,0 +1,12 @@
+const relativeToTransformReady = require('./relative-to-transform-ready');
+const lexicalTransform = require('./_lexical-transform');
+
+function lexicalRelativeToTransformReady(serializedLexical, siteUrl, itemPath, _options = {}) {
+    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
+    const overrideOptions = {siteUrl, transformType: 'toTransformReady'};
+    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+
+    return lexicalTransform(serializedLexical, siteUrl, relativeToTransformReady, itemPath, options);
+}
+
+module.exports = lexicalRelativeToTransformReady;

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

@@ -0,0 +1,13 @@
+const lexicalRelativeToAbsolute = require('./lexical-relative-to-absolute');
+const lexicalAbsoluteToTransformReady = require('./lexical-absolute-to-transform-ready');
+
+function lexicalToTransformReady(lexical, siteUrl, itemPath, options) {
+    if (typeof itemPath === 'object' && !options) {
+        options = itemPath;
+        itemPath = null;
+    }
+    const absolute = lexicalRelativeToAbsolute(lexical, siteUrl, itemPath, options);
+    return lexicalAbsoluteToTransformReady(absolute, siteUrl, options);
+}
+
+module.exports = lexicalToTransformReady;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/url-utils",
-  "version": "4.0.3",
+  "version": "4.2.0",
   "repository": "https://github.com/TryGhost/SDK/tree/master/packages/url-utils",
   "author": "Ghost Foundation",
   "license": "MIT",
@@ -34,5 +34,5 @@
     "remark-footnotes": "^1.0.0",
     "unist-util-visit": "^2.0.0"
   },
-  "gitHead": "9251588cb81347205c5dab850636bba4c86fe58d"
+  "gitHead": "7e8faa4260a758bca46ef7f6ff7ed0bd7ec21a13"
 }