@silvermine/toolbox 0.1.0 → 0.2.0

package/src/utils/escape-html.ts

@@ -0,0 +1,24 @@
+import { isString } from './is-string';
+
+const ESCAPE_ENTITIES: Record<string, string> = {
+   '&': '&amp;',
+   '<': '&lt;',
+   '>': '&gt;',
+   '"': '&quot;',
+   "'": '&#x27;', // eslint-disable-line quotes
+   '`': '&#x60;',
+};
+
+const ESCAPE_ENTITIES_PATTERN = '(?:' + Object.keys(ESCAPE_ENTITIES).join('|') + ')',
+      ESCAPE_ENTITIES_REGEX = new RegExp(ESCAPE_ENTITIES_PATTERN),
+      ESCAPE_ENTITIES_REPLACE_REGEX = new RegExp(ESCAPE_ENTITIES_PATTERN, 'g');
+
+export function escapeHTML(str: unknown): unknown {
+   if (isString(str) && ESCAPE_ENTITIES_REGEX.test(str)) {
+      return str.replace(ESCAPE_ENTITIES_REPLACE_REGEX, (match) => {
+         return ESCAPE_ENTITIES[match];
+      });
+   }
+
+   return str;
+}

package/src/utils/flatten.ts

@@ -1,5 +1,5 @@
-export function flatten<T>(...lists: T[][]): T[] {
-   return lists.reduce((memo, list) => {
+export function flatten<T>(...lists: Readonly<Readonly<T[]>[]>): T[] {
+   return lists.reduce((memo: T[], list) => {
       return memo.concat(list);
    }, [] as T[]);
 }

package/src/utils/get.ts

@@ -0,0 +1,156 @@
+/**
+ * Much of the code in this file is adapted from Lodash's _.get implementation:
+ *
+ * https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/get.js
+ * https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/.internal/baseGet.js
+ * https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/.internal/castPath.js
+ * https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/.internal/stringToPath.js
+ * https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/.internal/toKey.js
+ */
+import { getTagString } from './get-tag-string';
+import { isObject } from './is-object';
+
+function isSymbol(value: unknown): value is symbol {
+   const type = typeof value;
+
+   return (type === 'symbol') || (
+      type === 'object' &&
+      value !== undefined &&
+      value !== null &&
+      getTagString(value) === '[object Symbol]'
+   );
+}
+
+function toKey(value: unknown): string | symbol {
+   if (typeof value === 'string' || isSymbol(value)) {
+      return value;
+   }
+
+   return Object.is(value, -0) ? '-0' : `${value}`;
+}
+
+const IS_DEEP_PROP_REGEX = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+      IS_PLAIN_PROP_REGEX = /^\w*$/;
+
+function isKey(value: any, object: any): boolean {
+   if (Array.isArray(value)) {
+      return false;
+   }
+   const type = typeof value;
+
+   if (type === 'number' || type === 'boolean' || value === null || value === undefined || isSymbol(value)) {
+      return true;
+   }
+
+   return IS_PLAIN_PROP_REGEX.test(value) || !IS_DEEP_PROP_REGEX.test(value) ||
+      (object !== null && object !== undefined && value in Object(object));
+}
+
+const DOT_CHAR_CODE = '.'.charCodeAt(0),
+      ESCAPE_CHAR_REGEX = /\\(\\)?/g;
+
+/* eslint-disable no-useless-concat */
+const PROP_NAME_REGEX = RegExp(
+   // Match anything that isn't a dot or bracket.
+   '[^.[\\]]+' + '|' +
+   // Or match property names within brackets.
+   '\\[(?:' +
+      // Match a non-string expression.
+      '([^"\'][^[]*)' + '|' +
+      // Or match strings (supports escaping characters).
+      '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+   ')\\]' + '|' +
+   // Or match "" as the space between consecutive dots or empty brackets.
+   '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))',
+   'g'
+);
+/* eslint-enable no-useless-concat */
+
+function stringToPath(str: string): string[] {
+   const result: string[] = [];
+
+   if (str.charCodeAt(0) === DOT_CHAR_CODE) {
+      result.push('');
+   }
+
+   str.replace(PROP_NAME_REGEX, (match, expression, quote, subString) => {
+      let key = match;
+
+      if (quote) {
+         key = subString.replace(ESCAPE_CHAR_REGEX, '$1');
+      } else if (expression) {
+         key = expression;
+      }
+
+      result.push(key);
+
+      // The types for this callback require us to return a string, but we don't really
+      // care about the result of the call to `replace`, so we just return an empty string
+      // here.
+      return '';
+   });
+
+   return result;
+}
+
+function createPathArray(value: any, object: any): string[] {
+   if (Array.isArray(value)) {
+      return value;
+   }
+
+   return isKey(value, object) ? [ value ] : stringToPath(value);
+}
+
+interface StringRepresentable {
+   toString(): string;
+}
+
+function get<TObject extends object, TKey extends keyof TObject>(
+   obj: TObject,
+   path: TKey | [TKey]
+): TObject[TKey] | undefined;
+function get<TObject extends object, TKey extends keyof TObject>(
+   obj: TObject,
+   path: TKey | [TKey],
+   defaultValue: TObject[TKey]
+): TObject[TKey];
+function get<TObject extends object, TResult = unknown>(
+   obj: TObject,
+   path: StringRepresentable | StringRepresentable[],
+   defaultValue: TResult
+): TResult;
+function get<TObject extends object, TResult = unknown>(
+   obj: TObject,
+   path: StringRepresentable | StringRepresentable[]
+): TResult | undefined;
+function get<TResult = unknown>(
+   obj: unknown,
+   path: StringRepresentable | StringRepresentable[],
+   defaultValue?: TResult
+): TResult | undefined {
+   if (!isObject(obj)) {
+      return defaultValue;
+   }
+
+   const pathArray = createPathArray(path, obj),
+         length = pathArray.length;
+
+   let index = 0,
+       resultObj: unknown = obj;
+
+   while (resultObj !== null && resultObj !== undefined && index < length) {
+      resultObj = (resultObj as any)[toKey(pathArray[index])];
+
+      index += 1;
+   }
+
+   const result = (index > 0 && index === length) ? resultObj : undefined;
+
+   if (result === undefined) {
+      return defaultValue;
+   }
+
+   return result as TResult | undefined;
+}
+
+export { get };

package/src/utils/is-not-null-or-undefined.ts

@@ -0,0 +1,10 @@
+import { isNull } from './is-null';
+import { isUndefined } from './is-undefined';
+
+
+/**
+ * Checks if `o` is not either null or undefined
+ */
+export function isNotNullOrUndefined<T>(o: T | null | undefined): o is T {
+   return !(isNull(o) || isUndefined(o));
+}

package/src/utils/is-null.ts

@@ -0,0 +1,3 @@
+export function isNull(val: unknown): val is null {
+   return val === null;
+}

package/src/utils/is-undefined.ts

@@ -1,3 +1,3 @@
-export function isUndefined(val: any): val is undefined {
+export function isUndefined(val: unknown): val is undefined {
    return (typeof val === 'undefined');
 }

package/src/utils/make-template.ts

@@ -0,0 +1,90 @@
+import { get } from './get';
+import { escapeHTML } from './escape-html';
+
+const DEFAULT_SETTINGS: ToolboxTemplateSettings = {
+   escape: /<%-([\s\S]+?)%>/g,
+   interpolate: /<%=([\s\S]+?)%>/g,
+};
+
+function getValue(path: string, data: any): unknown {
+   return get(data, (path || '').trim(), '');
+}
+
+export interface ToolboxTemplateSettings {
+   escape: { source: string };
+   interpolate: { source: string };
+}
+
+export interface ToolboxTemplateFunction {
+   (data: Record<string, any>): string;
+}
+
+/**
+ * A simple replacement for _.template from either Underscore or Lodash that removes the
+ * features that make those libraries incompatible with Content Security Policy (CSP).
+ * Specifically, this implementation supports only interpolation (escaped and unescaped)
+ * and does not support JS evaluation.
+ *
+ * Use this function just like you would have used _.template:
+ *
+ * ```ts
+ * template = template('Hello <%= name %>');
+ * console.log(template({ name: 'John Smith' }));
+ * ```
+ *
+ * This function only supports:
+ *
+ * `<%= … %>`: interpolate a value
+ * `<%- … %>`: interpolate and HTML escape a value
+ *
+ * The following are NOT supported:
+ *
+ * `<% … %>`: JS evaluation
+ * `<% print('Hello ' + epithet); %>`: JS evaluation with the print function
+ *
+ * Templating in Underscore/Lodash works by building/evaluation a JS function using a
+ * string, essentially using `eval()` to evaluate the string as JS. This meant that if
+ * your template referred to a variable that did not exist, you would see a JS error
+ * thrown. In this function, however, undefined variables in the template will result in
+ * an empty string placed in that location.
+ */
+export function makeTemplate(text: string, userSettings?: ToolboxTemplateSettings): (data: unknown) => string {
+   type TemplateFunction = (data: unknown) => unknown;
+
+   let parts: (TemplateFunction | string)[] = [],
+       index = 0,
+       settings = Object.assign({}, DEFAULT_SETTINGS, userSettings || {}),
+       regExpPattern, matcher;
+
+   regExpPattern = [
+      settings.escape.source,
+      settings.interpolate.source,
+   ];
+   matcher = new RegExp(regExpPattern.join('|') + '|$', 'g');
+
+   text.replace(matcher, (match, escape, interpolate, offset) => {
+      parts.push(text.slice(index, offset));
+      index = offset + match.length;
+
+      if (escape) {
+         parts.push((data: any) => {
+            return escapeHTML(getValue(escape, data));
+         });
+      } else if (interpolate) {
+         parts.push(getValue.bind(null, interpolate));
+      }
+
+      // The types for this callback require us to return a string, but we don't really
+      // care about the result of the call to `replace`, so we just return an empty string
+      // here.
+      return '';
+   });
+
+   return (data: unknown): string => {
+      return parts.reduce((memo, part): string => {
+         const result = (typeof part === 'function') ? `${part(data)}` : part;
+
+         return memo + result;
+      }, '') as string;
+   };
+}

package/src/utils/pluck.ts

@@ -1,4 +1,4 @@
-export function pluck<T, K extends keyof T>(sources: T[], key: K): T[K][] {
+export function pluck<T, K extends keyof T>(sources: readonly T[], key: K): T[K][] {
    return sources.map((o) => {
       return o[key];
    });

package/.nvmrc

@@ -1 +0,0 @@
-12.14.0