@loadmill/universal 0.3.46 → 0.3.49

package/src/manipulation-utils.ts

@@ -1,58 +0,0 @@
-const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
-
-export function stripSingleton(singleton, defaultValue: any = {}) {
-  if (!isEmpty(singleton)) {
-    return singleton[firstKey(singleton)];
-  } else {
-    return defaultValue;
-  }
-}
-
-export function firstKey(obj) {
-  return Object.keys(obj)[0];
-}
-
-export function objToSingletonArray(obj: {}, sort = true) {
-  const result = Object.keys(obj).map(key => ({ [key]: obj[key] }));
-
-  if (sort) {
-    result.sort(firstKeyComparator);
-  }
-
-  return result;
-}
-
-export function firstKeyComparator(o1, o2) {
-  const k1 = firstKey(o1);
-  const k2 = firstKey(o2);
-
-  return k1 < k2 ? -1 : k1 > k2 ? 1 : 0;
-}
-/**
- * {"a":1, "b":2} => [{"a":1}, {"b":2}]
- */
-export function fromObjectToArrayOfObjects(obj: object): { [name: string]: string }[] {
-  if (!obj) {
-    obj = {};
-  }
-
-  return Object.entries(obj)
-    .map(([name, value]) => {
-      return { [name]: value };
-    });
-}
-
-/**
- * Deletes all occurrences of a given property from the given object (nested)
- * { a:1, b: {a: 1, b: 2} } => { b: { b: 2 } }
- */
-export function deleteProp(obj: object, propToDelete: string) {
-  for (const prop of Object.keys(obj)) {
-
-    delete obj[propToDelete];
-
-    if (typeof obj[prop] === 'object') {
-      deleteProp(obj[prop], propToDelete);
-    }
-  }
-}

package/src/math-utils.ts

@@ -1,31 +0,0 @@
-import quickselect from 'quickselect';
-
-export function calcAvg(
-  value1: number,
-  weight1: number,
-  value2: number,
-  weight2: number
-) {
-  const totalWeight = weight1 + weight2;
-
-  if (!totalWeight) {
-    return 0;
-  }
-
-  const weighted1 = (weight1 / totalWeight) * value1;
-  const weighted2 = (weight2 / totalWeight) * value2;
-
-  return weighted1 + weighted2;
-}
-
-export function findMedian(array, compare?) {
-  const len = array.length;
-  if (len <= 1) {
-    return array[0];
-  }
-
-  const k = Math.ceil(len / 2);
-  quickselect(array, k, 0, len - 1, compare);
-
-  return array[k - 1];
-}

package/src/my-id.ts

@@ -1,3 +0,0 @@
-import uuid from 'uuid';
-
-export const myId = uuid.v4();

package/src/number-utils.ts

@@ -1,28 +0,0 @@
-export function numberify(num?: number | string | null, defaultValue = 0) {
-  if (num == null) {
-    return defaultValue;
-  } else {
-    return Number(num);
-  }
-}
-
-export function formatNumber(value: number, fractionDigits: number) {
-  if (fractionDigits === 0) {
-    return value + '';
-  }
-
-  // Throw away insignificant digits:
-  const factor = Math.pow(10, fractionDigits);
-  value = Math.round(value * factor) / factor;
-
-  if (Number.isInteger(value)) {
-    return value + '';
-  } else {
-    return (
-      value
-        .toFixed(fractionDigits)
-        // Remove trailing zeros:
-        .replace(/0*$/, '')
-    );
-  }
-}

package/src/object-map.ts

@@ -1,71 +0,0 @@
-const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
-
-export class ObjectMap<T = any> {
-  nextId: number = 0;
-  obj: { [key: string]: T } = {};
-
-  constructor(generateKey?) {
-    if (generateKey) {
-      this.generateKey = generateKey;
-    }
-  }
-
-  generateKey = () => '' + this.nextId++;
-
-  size = () => {
-    return Object.keys(this.obj).length;
-  };
-
-  clear = () => {
-    this.obj = {};
-  };
-
-  isEmpty = () => {
-    return isEmpty(this.obj);
-  };
-
-  get = (key) => {
-    return this.obj[key];
-  };
-
-  forEach = (fn) => Object.keys(this.obj).forEach((key, i) => fn(this.obj[key], key, i));
-
-  pop = (key) => {
-    const value = this.obj[key];
-    this.remove(key);
-    return value;
-  };
-
-  getOrMake = (key, provider = () => ({} as T)) => {
-    const value = this.obj[key];
-
-    return value != null ? value : (this.obj[key] = provider());
-  };
-
-  put = (key, value: T) => {
-    this.obj[key] = value;
-  };
-
-  putIfAbsent = (key, value: T) => {
-    return this.getOrMake(key, () => value);
-  };
-
-  add = (value: T) => {
-    const key = this.generateKey();
-    this.put(key, value);
-    return key;
-  };
-
-  remove = (key) => {
-    delete this.obj[key];
-  };
-
-  mark = (keyAndValue: T) => {
-    const previous = this.get(keyAndValue);
-    this.put(keyAndValue, keyAndValue);
-
-    return previous == null;
-  };
-
-  hasKey = (key) => this.get(key) != null;
-}

package/src/promise-utils.ts

@@ -1,3 +0,0 @@
-export function delay(timeout: number) {
-  return new Promise(resolve => setTimeout(resolve, timeout));
-}

package/src/string-utils.ts

@@ -1,66 +0,0 @@
-// split("foo 'bar baz'")
-// ["foo", "bar baz"]
-export const split = (line: string) => {
-  let field: string;
-  if (line == null) {
-    line = '';
-  }
-  const words: string[] = [];
-  field = '';
-
-  const regex = /\s*(?:([^\s\\'"]+)|'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"|(\\.?)|(\S))(\s|$)?/;
-
-  _scan(line, regex, (match) => {
-    let dq, escape, garbage, seperator, sq, word;
-    word = match[1], sq = match[2], dq = match[3], escape = match[4], garbage = match[5], seperator = match[6];
-    if (garbage != null) {
-      throw new Error('Unmatched quote');
-    }
-    if (!word && !sq && !dq && !escape) {
-      field = '';
-    } else {
-      field += word || (sq || dq || escape).replace(/\\(?=.)/, '');
-    }
-    if (seperator != null) {
-      words.push(field);
-      return field = '';
-    }
-  });
-  if (field != null) {
-    words.push(field);
-  }
-  return words;
-};
-
-const _scan = (string, pattern, callback) => {
-  let result = '';
-  while (string.length > 0) {
-    const match = string.match(pattern);
-    if (match) {
-      result += string.slice(0, match.index);
-      result += callback(match);
-      string = string.slice(match.index + match[0].length);
-    } else {
-      result += string;
-      string = '';
-    }
-  }
-  return result;
-};
-
-// escape("What's up, yo?") => 'What\\\'s\\ up,\\ yo\\?'
-export const escape = (s: string): string => {
-  if (s == null) {
-    s = '';
-  }
-  if (s == null) {
-    return '\'\'';
-  }
-  return s.replace(/([^A-Za-z0-9_\-.,:/@\n])/g, '\\$1').replace(/\n/g, '\'\n\'');
-};
-
-export const nodeBtoa = (str = '') => Buffer.from(str).toString('base64');
-
-export const isNonEmptyString = (s: unknown): boolean => {
-  return !!s && typeof s === 'string';
-};

package/src/typescript-utils.ts

@@ -1,27 +0,0 @@
-/**
- * example usage of this function:
- * arr = [{ id: 1 }, { id: 2 }]
- * b = { uid: 2 }
- * const found = ensure(arr.find((a) => a.id === b.uid)); // TS thinks `find` might return undefined.
- * We know it will never be undefined, so we use `ensure` to tell TS that arg is defined and has value.
- * @param arg a value which should be defined and initialized
- * @param msg custom error message
- * @returns arg if it is defined, otherwise throws TypeError
- * @throws TypeError if arg is null or undefined
- */
-export function ensure<T>(arg?: T | null, msg: string = 'This value was supposed to be defined'): T {
-  if (arg == null) {
-    throw new TypeError(msg);
-  }
-
-  return arg;
-}
-
-/*
- * https://giphy.com/gifs/cbs-ghosts-ghostscbs-cbs-zXm8DwxWP2upMOQcQX
- */
-export type AllKeys<T> = T extends unknown ? keyof T : never;
-export type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-export type _ExclusifyUnion<T, K extends PropertyKey> =
-  T extends unknown ? Id<T & Partial<Record<Exclude<K, keyof T>, never>>> : never;
-export type XOR<T> = _ExclusifyUnion<T, AllKeys<T>>; // usage: XOR<Type1, Type2> -> only Type1 or Type2, but no overlap

package/src/uri-utils.ts

@@ -1,72 +0,0 @@
-import URI from 'urijs';
-
-const SUPPORTED_PROTOCOLS = ['http', 'https', 'ws', 'wss'];
-
-const isUrlStartsWithSupportedProtocol = (url: string, delimiter = ':') =>
-  SUPPORTED_PROTOCOLS.some(protocol =>
-    url.startsWith(protocol + delimiter)
-  );
-
-export function withProtocol(url: string) {
-  if (url && !isUrlStartsWithSupportedProtocol(url)) {
-    url = 'http://' + url;
-  }
-  return url;
-}
-
-export function parseQuery(query: string) {
-  return URI.parseQuery(query) as any;
-}
-
-export function getDomain(url) {
-  const parsedUri = new URI(url);
-  return normalizeDomain(parsedUri.host());
-}
-
-export function normalizeDomain(domain?: string) {
-  return (
-    stripProtocol(domain || '')
-      .toLowerCase()
-      // No trailing `/`:
-      .replace(/\/$/, '')
-  );
-}
-
-export function stripProtocol(urlish: string) {
-  if (isUrlStartsWithSupportedProtocol(urlish, '://')) {
-    const url = new URI(urlish);
-    const protocolLength = url.protocol().length;
-    return urlish.substring(protocolLength + 3, urlish.length);
-  }
-
-  return urlish;
-}
-
-export function encodePart(urlPart: string) {
-  return URI.encode(urlPart);
-}
-
-export function decodePart(urlPart: string) {
-  return URI.decode(urlPart);
-}
-
-export function isVerified(domain: string, verifiedDomains: string[]) {
-  return !!verifiedDomains.find((verifiedDomain) =>
-    isSubDomain(domain, verifiedDomain)
-  );
-}
-
-export function getFullUrl (url: string) {
-  return new URL(withProtocol(url)).href;
-}
-
-/**
- * Assumes both domains are properly normalized.
- *
- * @param domain1 Potential sub-domain of `domain2`.
- * @param domain2 Potential parent domain of `domain1`.
- * @returns True if domain1 is equal to or a sub-domain of domain2.
- */
-function isSubDomain(domain1: string, domain2: string): boolean {
-  return domain1 === domain2 || domain1.endsWith('.' + domain2);
-}

package/test/array-utils.spec.js

@@ -1,35 +0,0 @@
-const { expect } = require('chai');
-const { describe, it } = require('mocha');
-const { parameterUtils } = require('../../core/dist/parameters');
-const arrayUtils = require('../dist/array-utils');
-
-describe('array-utils', () => {
-  describe('swap', () => {
-    it('Validate swap top down', () => {
-      const arr1 = [0, 1, 2, 3];
-      arrayUtils.swap(arr1, 3, 0);
-      expect(arr1).deep.equal([3, 0, 1, 2]);
-    });
-
-    it('Validate swap bottom up', () => {
-      const arr2 = [0, 1, 2, 3];
-      arrayUtils.swap(arr2, 0, 3);
-      expect(arr2).deep.equal([1, 2, 3, 0]);
-    });
-
-    it('Validate swap with an array of objects', () => {
-      const arr3 = [{ order: 0 }, { order: 1 }, { order: 2 }, { order: 3 }];
-      arrayUtils.swap(arr3, 3, 0);
-      expect(arr3).deep.equal([{ order: 3 }, { order: 0 }, { order: 1 }, { order: 2 }]);
-    });
-
-    it('uniqByKeepLast function', () => {
-      let params = [{ a: 1 }, { a: 2 }, { a: 3 }];
-      expect(arrayUtils.uniqByKeepLast(params, parameterUtils.getParameterName)).to.eql([{ a: 3 }]);
-      params = [{ a: 1 }, { b: 2 }];
-      expect(arrayUtils.uniqByKeepLast(params, parameterUtils.getParameterName)).to.eql([{ a: 1 }, { b:2 }]);
-      params = [{ a: 1 }, { b: 2 }, { a: 4 }];
-      expect(arrayUtils.uniqByKeepLast(params, parameterUtils.getParameterName)).to.eql([{ b:2 }, { a:4 }]);
-    });
-  });
-});

package/test/cron-utils.spec.js

@@ -1,39 +0,0 @@
-const { expect } = require('chai');
-const { describe, it } = require('mocha');
-
-const { getCronLabel, isAllowedExpression } = require('../dist/cron-utils');
-
-describe('cron-utils', () => {
-  it('getCronLabel', () => {
-    expect(getCronLabel('1')).equals('');
-    expect(getCronLabel('No scheduling')).equals('No scheduling');
-    expect(getCronLabel('*/10 * * * *')).equals('Every 10 minutes');
-    expect(getCronLabel('0 */1 * * *')).equals('Every 1 Hour');
-    expect(getCronLabel('0 2 * * *')).equals('Every night');
-    expect(getCronLabel('0 1 * * 1')).equals('Once a Week');
-    expect(getCronLabel('0 1 * * 2')).equals('Once a Week');
-    expect(getCronLabel('0 3 * * 2')).equals('Once a Week');
-    expect(getCronLabel('0 10 * * 2')).equals('Once a Week');
-    expect(getCronLabel('0 15 * * 2')).equals('Once a Week');
-    expect(getCronLabel('0 23 * * 2')).equals('Once a Week');
-    expect(getCronLabel('0 0 * * 6')).equals('Once a Week');
-    expect(getCronLabel('0 23 * * 7')).equals('');
-    expect(getCronLabel('0 24 * * 2')).equals('');
-    expect(getCronLabel('0 */1 * * 2')).equals('');
-    expect(getCronLabel('1 3 * * 2')).equals('');
-    expect(getCronLabel('0 /3 * * 2')).equals('');
-  });
-
-  it('isAllowedExpression', () => {
-    expect(isAllowedExpression('1')).equals(false);
-    expect(isAllowedExpression('No scheduling')).equals(true);
-    expect(isAllowedExpression('*/10 * * * *')).equals(true);
-    expect(isAllowedExpression('0 */1 * * *')).equals(true);
-    expect(isAllowedExpression('0 2 * * *')).equals(true);
-    expect(isAllowedExpression('0 1 * * 1')).equals(true);
-    expect(isAllowedExpression('0 1 * * 2')).equals(true);
-    expect(isAllowedExpression('0 3 * * 2')).equals(true);
-    expect(isAllowedExpression('1 3 * * 2')).equals(false);
-    expect(isAllowedExpression('0 /3 * * 2')).equals(false);
-  });
-});

package/test/manipulation-utils.spec.js

@@ -1,168 +0,0 @@
-const { expect } = require('chai');
-const { describe, it } = require('mocha');
-
-const { deleteProp } = require('../dist/manipulation-utils');
-
-describe('delete Prop', () => {
-  it('should delete all nested props named "arnon" from object', () => {
-    const objectUnderTest = {
-      arnon: 1,
-      yochai: {
-        arnon: 1,
-        yochai: {
-          arnon: 1,
-          yochai: {
-            arnon: {
-              rivi: 'what am I doing here?',
-              shimi: 'we don\'t belong here'
-            },
-            yochai: 2
-          }
-        }
-      }
-    };
-    deleteProp(objectUnderTest, 'arnon');
-    const expected = {
-      yochai: {
-        yochai: {
-          yochai: {
-            yochai: 2
-          }
-        }
-      }
-    };
-    expect(objectUnderTest).eql(expected);
-  });
-  it('should delete all nested props named "title" (also from array)', () => {
-    const objectUnderTest = {
-      'type': 'object',
-      'properties': {
-        'slideshow': {
-          'type': 'object',
-          'properties': {
-            'author': {
-              'type': 'string',
-              'const': 'Yours Truly'
-            },
-            'date': {
-              'type': 'string',
-              'const': 'date of publication'
-            },
-            'slides': {
-              'type': 'array',
-              'items': {
-                'anyOf': [
-                  {
-                    'type': 'object',
-                    'properties': {
-                      'title': {
-                        'type': 'string',
-                        'const': 'Wake up to WonderWidgets!'
-                      },
-                      'type': {
-                        'type': 'string',
-                        'const': 'all'
-                      }
-                    }
-                  },
-                  {
-                    'type': 'object',
-                    'properties': {
-                      'items': {
-                        'type': 'array',
-                        'items': {
-                          'anyOf': [
-                            {
-                              'type': 'string',
-                              'const': 'Why <em>WonderWidgets</em> are great'
-                            },
-                            {
-                              'type': 'string',
-                              'const': 'Who <em>buys</em> WonderWidgets'
-                            }
-                          ]
-                        }
-                      },
-                      'title': {
-                        'type': 'string',
-                        'const': 'Overview'
-                      },
-                      'type': {
-                        'type': 'string',
-                        'const': 'all'
-                      }
-                    }
-                  }
-                ]
-              }
-            },
-            'title': {
-              'type': 'string',
-              'const': 'Sample Slide Show'
-            }
-          }
-        }
-      }
-    };
-    deleteProp(objectUnderTest, 'title');
-    const expected = {
-      'type': 'object',
-      'properties': {
-        'slideshow': {
-          'type': 'object',
-          'properties': {
-            'author': {
-              'type': 'string',
-              'const': 'Yours Truly'
-            },
-            'date': {
-              'type': 'string',
-              'const': 'date of publication'
-            },
-            'slides': {
-              'type': 'array',
-              'items': {
-                'anyOf': [
-                  {
-                    'type': 'object',
-                    'properties': {
-                      'type': {
-                        'type': 'string',
-                        'const': 'all'
-                      }
-                    }
-                  },
-                  {
-                    'type': 'object',
-                    'properties': {
-                      'items': {
-                        'type': 'array',
-                        'items': {
-                          'anyOf': [
-                            {
-                              'type': 'string',
-                              'const': 'Why <em>WonderWidgets</em> are great'
-                            },
-                            {
-                              'type': 'string',
-                              'const': 'Who <em>buys</em> WonderWidgets'
-                            }
-                          ]
-                        }
-                      },
-                      'type': {
-                        'type': 'string',
-                        'const': 'all'
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          }
-        }
-      }
-    };
-    expect(objectUnderTest).eql(expected);
-  });
-});

package/test/object-map.spec.js

@@ -1,15 +0,0 @@
-const { expect } = require('chai');
-const { ObjectMap } = require('../dist/object-map');
-const { describe, it } = require('mocha');
-
-describe('Object Map', () => {
-  it('Overrides values', () => {
-    const objectMap = new ObjectMap();
-    const key = objectMap.add('Hey');
-
-    const expected = 'YO!';
-    objectMap.put(key, expected);
-
-    expect(objectMap.get(key)).equals(expected);
-  });
-});