Added Types to Simple Utility Functions

- This adds types to simple utilities with no dependencies on other utils

Author: vershwal

packages/url-utils/src/utils/deduplicate-double-slashes.ts

@@ -1,6 +1,6 @@
-// @ts-nocheck
-function deduplicateDoubleSlashes(url) {
+function deduplicateDoubleSlashes(url: string): string {
     return url.replace(/\/\//g, '/');
 }
 
+export default deduplicateDoubleSlashes;
 module.exports = deduplicateDoubleSlashes;

packages/url-utils/src/utils/deduplicate-subdirectory.ts

@@ -1,5 +1,4 @@
-// @ts-nocheck
-const {URL} = require('url');
+import {URL} from 'url';
 
 /**
  * Remove duplicated directories from the start of a path or url's path
@@ -8,7 +7,7 @@ const {URL} = require('url');
  * @param {string} rootUrl Root URL with an optional subdirectory
  * @returns {string} URL or pathname with any duplicated subdirectory removed
  */
-const deduplicateSubdirectory = function deduplicateSubdirectory(url, rootUrl) {
+const deduplicateSubdirectory = function deduplicateSubdirectory(url: string, rootUrl: string): string {
     // force root url to always have a trailing-slash for consistent behaviour
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
@@ -29,4 +28,5 @@ const deduplicateSubdirectory = function deduplicateSubdirectory(url, rootUrl) {
     return url.replace(subdirRegex, `$1${subdir}/`);
 };
 
+export default deduplicateSubdirectory;
 module.exports = deduplicateSubdirectory;

packages/url-utils/src/utils/index.ts

@@ -1,15 +1,22 @@
 // @ts-nocheck
+import deduplicateDoubleSlashes from './deduplicate-double-slashes';
+import deduplicateSubdirectory from './deduplicate-subdirectory';
+import isSSL from './is-ssl';
+import replacePermalink from './replace-permalink';
+import stripSubdirectoryFromPath from './strip-subdirectory-from-path';
+import urlJoin from './url-join';
+
 module.exports = {
     absoluteToRelative: require('./absolute-to-relative'),
     absoluteToTransformReady: require('./absolute-to-transform-ready'),
-    deduplicateDoubleSlashes: require('./deduplicate-double-slashes'),
-    deduplicateSubdirectory: require('./deduplicate-subdirectory'),
+    deduplicateDoubleSlashes,
+    deduplicateSubdirectory,
     htmlAbsoluteToRelative: require('./html-absolute-to-relative'),
     htmlRelativeToAbsolute: require('./html-relative-to-absolute'),
     htmlAbsoluteToTransformReady: require('./html-absolute-to-transform-ready'),
     htmlRelativeToTransformReady: require('./html-relative-to-transform-ready'),
     htmlToTransformReady: require('./html-to-transform-ready'),
-    isSSL: require('./is-ssl'),
+    isSSL,
     markdownAbsoluteToRelative: require('./markdown-absolute-to-relative'),
     markdownRelativeToAbsolute: require('./markdown-relative-to-absolute'),
     markdownAbsoluteToTransformReady: require('./markdown-absolute-to-transform-ready'),
@@ -30,10 +37,10 @@ module.exports = {
     plaintextToTransformReady: require('./plaintext-to-transform-ready'),
     relativeToAbsolute: require('./relative-to-absolute'),
     relativeToTransformReady: require('./relative-to-transform-ready'),
-    replacePermalink: require('./replace-permalink'),
-    stripSubdirectoryFromPath: require('./strip-subdirectory-from-path'),
+    replacePermalink,
+    stripSubdirectoryFromPath,
     toTransformReady: require('./to-transform-ready'),
     transformReadyToAbsolute: require('./transform-ready-to-absolute'),
     transformReadyToRelative: require('./transform-ready-to-relative'),
-    urlJoin: require('./url-join')
+    urlJoin
 };

packages/url-utils/src/utils/is-ssl.ts

@@ -1,10 +1,10 @@
-// @ts-nocheck
 // require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
+import {URL} from 'url';
 
-function isSSL(urlToParse) {
+function isSSL(urlToParse: string): boolean {
     const {protocol} = new URL(urlToParse);
     return protocol === 'https:';
 }
 
+export default isSSL;
 module.exports = isSSL;

packages/url-utils/src/utils/relative-to-absolute.ts

@@ -1,7 +1,6 @@
-// @ts-nocheck
 // require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
-const urlJoin = require('./url-join');
+import {URL} from 'url';
+import urlJoin from './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
@@ -12,6 +11,12 @@ const urlJoin = require('./url-join');
 // this when all root-relative paths are treated as subdir-relative we have to
 // rely on subdirectory deduplication.
 
+interface RelativeToAbsoluteOptions {
+    assetsOnly?: boolean;
+    staticImageUrlPrefix?: string;
+    secure?: boolean;
+}
+
 /**
  * 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)
@@ -22,24 +27,36 @@ const urlJoin = require('./url-join');
  * @param {object} options
  * @returns {string} The passed in url or an absolute URL using
  */
-const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath, _options) {
+const relativeToAbsolute = function relativeToAbsolute(
+    path: string,
+    rootUrl: string,
+    itemPath?: string | RelativeToAbsoluteOptions | null,
+    _options?: RelativeToAbsoluteOptions
+): string {
     // itemPath is optional, if it's an object it may be the options param instead
-    if (typeof itemPath === 'object' && !_options) {
-        _options = itemPath;
-        itemPath = null;
+    let actualItemPath: string | null = null;
+    let actualOptions: RelativeToAbsoluteOptions;
+    
+    if (itemPath && typeof itemPath === 'object' && !_options) {
+        actualOptions = itemPath;
+        actualItemPath = null;
+    } else {
+        actualOptions = _options || {};
+        actualItemPath = typeof itemPath === 'string' ? 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;
+    if (actualItemPath && actualItemPath.match(/^http/)) {
+        const itemUrl = new URL(actualItemPath);
+        actualItemPath = itemUrl.pathname;
     }
 
-    const defaultOptions = {
+    const defaultOptions: Required<RelativeToAbsoluteOptions> = {
         assetsOnly: false,
-        staticImageUrlPrefix: 'content/images'
+        staticImageUrlPrefix: 'content/images',
+        secure: false
     };
-    const options = Object.assign({}, defaultOptions, _options);
+    const options = Object.assign({}, defaultOptions, actualOptions);
 
     // return the path as-is if it's not an asset path and we're only modifying assets
     if (options.assetsOnly) {
@@ -81,7 +98,7 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
     }
 
     const parsedRootUrl = new URL(rootUrl);
-    const basePath = path.startsWith('/') ? '' : itemPath;
+    const basePath = path.startsWith('/') ? '' : (actualItemPath || '');
     const fullPath = urlJoin([parsedRootUrl.pathname, basePath, path], {rootUrl});
     const absoluteUrl = new URL(fullPath, rootUrl);
 
@@ -92,4 +109,5 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
     return absoluteUrl.toString();
 };
 
+export default relativeToAbsolute;
 module.exports = relativeToAbsolute;

packages/url-utils/src/utils/replace-permalink.ts

@@ -1,14 +1,25 @@
-// @ts-nocheck
-const moment = require('moment-timezone');
+import moment from 'moment-timezone';
+
+interface PermalinkResource {
+    published_at?: string | number | Date;
+    primary_author?: {
+        slug: string;
+    };
+    primary_tag?: {
+        slug: string;
+    };
+    slug: string;
+    id: string | number;
+}
 
 /**
  * creates the url path for a post based on blog timezone and permalink pattern
  */
-function replacePermalink(permalink, resource, timezone = 'UTC') {
+function replacePermalink(permalink: string, resource: PermalinkResource, timezone: string = 'UTC'): string {
     const output = permalink;
     const primaryTagFallback = 'all';
     const publishedAtMoment = moment.tz(resource.published_at || Date.now(), timezone);
-    const permalinkLookUp = {
+    const permalinkLookUp: Record<string, () => string> = {
         year: function () {
             return publishedAtMoment.format('YYYY');
         },
@@ -19,7 +30,7 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return publishedAtMoment.format('DD');
         },
         author: function () {
-            return resource.primary_author.slug;
+            return resource.primary_author!.slug;
         },
         primary_author: function () {
             return resource.primary_author ? resource.primary_author.slug : primaryTagFallback;
@@ -31,17 +42,22 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return resource.slug;
         },
         id: function () {
-            return resource.id;
+            return String(resource.id);
         }
     };
 
     // replace tags like :slug or :year with actual values
     const permalinkKeys = Object.keys(permalinkLookUp);
-    return output.replace(/(:[a-z_]+)/g, function (match) {
-        if (permalinkKeys.includes(match.substr(1))) {
-            return permalinkLookUp[match.substr(1)]();
+    return output.replace(/(:[a-z_]+)/g, function (match: string): string {
+        const key = match.substr(1);
+        if (permalinkKeys.includes(key)) {
+            // Known route segment - use the lookup function
+            return permalinkLookUp[key]();
         }
+        // Unknown route segment - return 'undefined' string
+        return 'undefined';
     });
 }
 
+export default replacePermalink;
 module.exports = replacePermalink;

packages/url-utils/src/utils/strip-subdirectory-from-path.ts

@@ -1,5 +1,4 @@
-// @ts-nocheck
-const {URL} = require('url');
+import {URL} from 'url';
 
 /**
  * Removes the directory in the root url from the relative path
@@ -8,13 +7,13 @@ const {URL} = require('url');
  * @param {string} rootUrl Root URL (eg, 'https://mysite.com/my/subdir/)
  * @returns {string} Path relative to the rootUrl's path
  */
-const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '', rootUrl = '') {
+const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path: string = '', rootUrl: string = ''): string {
     // force root to always have a trailing-slash for consistent behaviour
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
 
-    let parsedRoot;
+    let parsedRoot: URL;
 
     try {
         parsedRoot = new URL(rootUrl);
@@ -34,4 +33,5 @@ const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '',
     return path;
 };
 
+export default stripSubdirectoryFromPath;
 module.exports = stripSubdirectoryFromPath;

packages/url-utils/src/utils/url-join.ts

@@ -1,5 +1,8 @@
-// @ts-nocheck
-const deduplicateSubdirectory = require('./deduplicate-subdirectory');
+import deduplicateSubdirectory from './deduplicate-subdirectory';
+
+interface UrlJoinOptions {
+    rootUrl: string;
+}
 
 /** urlJoin
 * Returns a URL/path for internal use in Ghost.
@@ -8,7 +11,7 @@ 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: string[], options: UrlJoinOptions): string {
     let prefixDoubleSlash = false;
 
     // Remove empty item at the beginning
@@ -35,4 +38,5 @@ function urlJoin(parts, options) {
     return deduplicateSubdirectory(url, options.rootUrl);
 }
 
+export default urlJoin;
 module.exports = urlJoin;