arrmatura 4.2.2 → 5.0.2

package/lib/arrayGroupBy.ts

@@ -0,0 +1,19 @@
+import { gettus } from 'obj';
+
+type GroupOf<T> = { id: string; count: number; items: T[] };
+
+/**
+ * Builds histogram on given field for given list.
+ *
+ * @param {*} list source
+ * @param {*} field to be used as group key
+ */
+export const arrayGroupBy = function <T extends Obj>(list: T[], field = 'type', result: Hash<GroupOf<T>> = {}) {
+  const iter = (v: string, entry: T) => {
+    const slot = result[v] || (result[v] = { id: v, count: 0, items: [] });
+    slot.count++;
+    (slot.items || (slot.items = [])).push(entry);
+  };
+  list?.forEach((e: T) => iter(gettus(e, field) as string, e));
+  return result;
+};

package/lib/arraySortBy.ts

@@ -0,0 +1,49 @@
+export enum ComparatorDirection {
+  DESC = -1,
+  ASC = 1,
+}
+
+export enum ComparatorResult {
+  EQ = 0,
+  LESS = -1,
+  MORE = 1,
+}
+type Comparable = Hash<number | string>;
+type Comparator<T> = (a: T, b: T) => ComparatorResult;
+
+const sortByComparator = <T extends Comparable>(
+  fn: string | ((e: T) => number | string),
+  dir: ComparatorDirection = 1
+): Comparator<T> => {
+  let order: ComparatorResult = dir === 1 ? 1 : -1;
+  let negOrder: ComparatorResult = dir === 1 ? -1 : 1;
+  if (typeof fn === 'string') {
+    let key = fn;
+    if (key[0] === '-') {
+      order = -1;
+      negOrder = 1;
+      key = fn.substr(1);
+    }
+    return (a: T, b: T): ComparatorResult => {
+      const aa = a[fn];
+      const bb = b[fn];
+      return aa < bb ? negOrder : aa > bb ? order : 0;
+    };
+  }
+  return (a: T, b: T): ComparatorResult => {
+    const aa = fn(a);
+    const bb = fn(b);
+    return aa < bb ? negOrder : aa > bb ? order : 0;
+  };
+};
+
+/**
+ * Sorts array by element property
+ */
+export const arraySortBy = function sortBy(
+  arr: Comparable[],
+  property = 'name',
+  order: ComparatorDirection = ComparatorDirection.ASC
+) {
+  return (arr || []).slice(0).sort(sortByComparator(property, order));
+};

package/lib/arrayToObject.ts

@@ -0,0 +1,18 @@
+/**
+ * Produces key/value index on given array.
+ *
+ * @param {*} arr source array
+ * @param {*} idKey id key
+ * @param {*} valKey value key
+ */
+export const arrayToObject = (arr: unknown[], idKey: string | Function = 'id', valKey?: string | Function) => {
+  const r: Obj = {};
+  if (arr) {
+    const idFn = typeof idKey === 'string' ? (e: Obj) => e[idKey] : idKey;
+    const valFn = typeof valKey === 'string' ? (e: Obj) => e[valKey] : valKey;
+    arr.forEach((e) => {
+      r[idFn(e)] = valFn ? valFn(e) : e;
+    });
+  }
+  return r;
+};

package/lib/codus.ts

@@ -0,0 +1,25 @@
+import { scalarParse } from 'scalar';
+
+export const decodus = (val: string): unknown => {
+  if (!val) return undefined;
+
+  const value = decodeURIComponent(val);
+  if ('{['.indexOf(value[0]) > -1) {
+    try {
+      return JSON.parse(value);
+    } catch (e) {
+      return undefined;
+    }
+  }
+  return scalarParse(value);
+};
+
+export const encodus = (value: unknown): string => {
+  if (typeof value === 'undefined') {
+    return '';
+  }
+  if (typeof value === 'object') {
+    return value ? encodeURIComponent(JSON.stringify(value)) : 'null';
+  }
+  return encodeURIComponent(String(value));
+};

package/lib/consts.ts

@@ -0,0 +1,3 @@
+export const EMPTY_OBJECT = Object.freeze({});
+
+export const ARRAY_EMPTY = Object.freeze([]);

package/lib/createListeners.ts

@@ -0,0 +1,12 @@
+export function createListeners<T = void>(): Listeners<T> {
+  const listeners = new Set<(event: T) => void>();
+  return {
+    add(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    notify(event) {
+      listeners.forEach((fn) => fn(event));
+    },
+  };
+}

package/lib/curry.ts

@@ -0,0 +1,8 @@
+const _curry = <S>(fn: (...args: unknown[]) => S, args0: unknown[], lengthLimit: number): (() => S) => {
+  const fx = (args: unknown[]) =>
+    args.length >= lengthLimit ? fn(...args) : _curry(fn, args, lengthLimit - args.length);
+
+  return (...args: unknown[]) => fx([...args0, ...args]);
+};
+
+export const curry = <S>(fn: () => S, ...args: S[]): S | (() => S) => _curry<S>(fn, args, fn.length);

package/lib/dateFormat.ts

@@ -0,0 +1,69 @@
+import { dateOf } from 'dateOf';
+import { t } from 'l10n';
+import { padLeft } from 'str';
+
+export const daysInMonth = (month: number, year: number) => new Date(year, month + 1, 0).getDate();
+
+export const firstOfWeek = (x: Dateable) => {
+  const d = dateOf(x);
+  return !d ? null : new Date(d.getFullYear(), d.getMonth(), d.getDate() - d.getDay());
+};
+
+export const monthName = (m: number, mode = ''): string => t(`monthNames${mode}.${m}`) as string;
+
+export const fractions = (d: Date = new Date()) => [
+  d.getFullYear(),
+  d.getMonth(),
+  d.getDate(),
+  d.getHours(),
+  d.getMinutes(),
+  d.getSeconds(),
+  d.getMilliseconds(),
+];
+
+export const formatTimezone = (tzOffset: string | number) => {
+  const toNumber = Number(tzOffset);
+  return toNumber
+    ? toNumber >= 0
+      ? `+${padLeft(toNumber / 60)}:${padLeft(toNumber % 60)}`
+      : `-${padLeft(-toNumber / 60)}:${padLeft(-toNumber % 60)}`
+    : '';
+};
+
+const DATE_FORMATTERS: Hash<(date: Date) => string> = {
+  hh: (date: Date) => padLeft(date.getHours()),
+  ii: (date: Date) => padLeft(date.getMinutes()),
+  hi: (date: Date) => padLeft(date.getHours()) + ':' + padLeft(date.getMinutes()),
+  dd: (date: Date) => padLeft(date.getDate()),
+  w: (date: Date) => '' + t(`dayNames.${date.getDay()}`),
+  ww: (date: Date) => '' + t(`dayNamesShort.${date.getDay()}`),
+  d: (date: Date) => '' + date.getDate(),
+  mmmm: (date: Date) => monthName(date.getMonth() + 1, ''),
+  mmm: (date: Date) => monthName(date.getMonth() + 1, 'Short'),
+  mm: (date: Date) => padLeft(date.getMonth() + 1),
+  MM: (date: Date) => padLeft(date.getMonth() + 1),
+  yyyy: (date: Date) => `${date.getFullYear()}`,
+  ll: (date: Date) => `${date.getTime()}`,
+  z: (date: Date) => `Z${formatTimezone(date.getTimezoneOffset())}`,
+};
+
+var DEFAULT_DATE_FORMAT = 'yyyy-mm-dd';
+
+export function setDefaultDateFormat(f: string) {
+  DEFAULT_DATE_FORMAT = f;
+}
+
+export const dateFormat = (x: Dateable | null, format = DEFAULT_DATE_FORMAT) => {
+  if (!x) {
+    return '';
+  }
+  const date = dateOf(x);
+  return !date
+    ? ''
+    : format.replace(/[_]/g, '\n').replace(/[hidwmylz]+/g, (key: string) => {
+        if (key in DATE_FORMATTERS) {
+          return DATE_FORMATTERS[key as keyof typeof DATE_FORMATTERS](date);
+        }
+        return key;
+      });
+};

package/lib/dateOf.ts

@@ -0,0 +1,31 @@
+import { dateParseISO8601 } from 'dateParseISO8601';
+
+/**
+ * Universal converter to Date.
+ *
+ * @returns Date instance or null
+ */
+export function dateOf(x: Dateable | null): Date | null {
+  if (x == null) {
+    return null;
+  }
+  if (typeof x === 'number') {
+    return new Date(x);
+  }
+  if (typeof x === 'object') {
+    // Date or has time
+    const dx = x as { getTime?: () => number };
+    if (dx.getTime) {
+      return new Date(dx.getTime());
+    }
+    // having a date representation
+    const ddx = x as { toDate?: () => Date };
+    if (ddx.toDate) {
+      return ddx.toDate();
+    }
+  }
+  if (typeof x === 'string') {
+    return dateParseISO8601(x);
+  }
+  return null;
+}

package/lib/dateParseISO8601.ts

@@ -0,0 +1,27 @@
+export const dateParseISO8601 = function (x: string, TZ = new Date().getTimezoneOffset()) {
+  if (!x) {
+    return null;
+  }
+  if (x.length === 10) {
+    x += 'T12:00';
+  }
+  const timebits =
+    /^([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2})(?::([0-9]*)(\.[0-9]*)?)?(Z?)(([+-])([0-9]{2})([0-9]{2}))?/;
+  const m = timebits.exec(x);
+  if (!m) {
+    return null;
+  }
+  const tz = m[8] ? (!m[9] ? 0 : (m[10] === '+' ? -1 : +1) * (parseInt(m[11]) * 60 + parseInt(m[12]))) : TZ;
+  // utcdate is milliseconds since the epoch
+  const utcdate = Date.UTC(
+    parseInt(m[1]),
+    parseInt(m[2]) - 1, // months are zero-offset (!)
+    parseInt(m[3]),
+    parseInt(m[4]),
+    parseInt(m[5]), // hh:mm
+    (m[6] && parseInt(m[6])) || 0, // optional seconds
+    (m[7] && parseFloat(m[7])) || 0
+  );
+
+  return new Date(utcdate + tz * 60000);
+};

package/lib/fx.ts

@@ -0,0 +1,62 @@
+/**
+ * Functions
+ */
+
+export * from './obj';
+
+export const assert = (b: unknown, error: string | Error, ErrorType = Error) => {
+  if (!b) {
+    throw typeof error === 'string' ? new ErrorType(error) : error;
+  }
+};
+
+export const log = (x: any, pre: string) => {
+  console.log(pre || 'pipe', x);
+  return x;
+};
+
+export const nextTick = (fn: any, lag: number) => {
+  return () => setTimeout(fn, lag);
+};
+
+export const callFn = (fn: any, ...args: number[]) => {
+  return fn(...args);
+};
+
+// arrayish:
+export const includes = (x: any, p: string) => x?.includes?.(p);
+export const slice = <T>(x: T[], b = 0, e?: number): T[] => (x ? x.slice(b, e) : []);
+
+// checks
+export const isTrue = (x: any) => x === true;
+export const isFalse = (x: any) => x === false;
+export const isUndefined = <T = unknown>(x: T): boolean => typeof x === 'undefined';
+
+// logical
+export const then = (x: any, p = '', n = '') => (x ? p : n);
+export const truthy = (x: any) => !!x;
+export const not = (x: any) => !x;
+export const or = (x: any, s: any) => x || s;
+export const and = (x: any, s: any) => x && s;
+
+// math
+// eslint-disable-next-line eqeqeq
+export const equals = (x: any, p: any) => x == p;
+export const greater = (x: any, p: any) => x > p;
+export const less = (x: any, p: any) => x < p;
+export const plus = (x: any, alt: any) => +x + +alt;
+export const minus = (x: any, alt: any) => +x - +alt;
+export const multiply = (x: any, alt: any) => +x * +alt;
+export const swap = (f: BinaryOp) => (a: unknown, b: unknown) => f(b, a);
+
+export const compose =
+  (...ff: ((e: unknown) => unknown)[]) =>
+  (x0: unknown) =>
+    ff.reduceRight((x: unknown, fn) => fn(x), x0);
+
+export const bindArgs = (fn: () => unknown, ...args: never[]) => fn?.bind(null, ...args);
+
+export const assignFirstArgKeyValue =
+  (fn: () => unknown, key: string, val: unknown) =>
+  (x: object, ...args: unknown[]) =>
+    fn(Object.assign(x || {}, { [key]: val }), ...args.slice(1));

package/lib/guid.ts

@@ -0,0 +1,7 @@
+/* Simple GUID generator. */
+const s4 = (): string =>
+  Math.floor((1 + Math.random()) * 0x10000)
+    .toString(16)
+    .substring(1);
+
+export const guid = (): string => `${s4()}${s4()}-${s4()}-${s4()}-${s4()}-${s4()}${s4()}${s4()}`;

package/lib/index.ts

@@ -0,0 +1,19 @@
+export * from './arrayGroupBy';
+export { arraySortBy } from './arraySortBy';
+export * from './arrayToObject';
+export * from './createListeners';
+export * from './curry';
+export * from './dateFormat';
+export * from './dateOf';
+export * from './dateParseISO8601';
+export * from './codus';
+export * from './fx';
+export * from './guid';
+export * from './l10n';
+export * from './nextId';
+export * from './noop';
+export * from './obj';
+export * from './scalar';
+export * from './str';
+export * from './urls';
+export * from './xml';

package/lib/l10n.ts

@@ -0,0 +1,40 @@
+import en from 'resources';
+import ru from 'resources.ru';
+
+const R = { en, ru };
+
+let LANG: keyof typeof R = 'en';
+
+export function setLang(lang: keyof typeof R = 'en'): void {
+  LANG = lang;
+}
+
+const deep = (path?: string[], lang = LANG) => {
+  let r: Bundle | Hash<string> | string = R[lang] as unknown as Bundle;
+  if (!path?.length) return r;
+  for (const k of path) {
+    r = r[k];
+    if (typeof r !== 'object') {
+      return undefined;
+    }
+  }
+
+  return typeof r === 'object' ? r : undefined;
+};
+
+export const t = (key: string, lang?: keyof typeof R) => {
+  const path = key ? key.split('.') : [];
+  const last = path.pop();
+  if (!last) return undefined;
+  const target = deep(path, lang);
+
+  return target ? target[last] : undefined;
+};
+
+export const appendResourceBundle = (bundle: Bundle, key?: string, lang = LANG) => {
+  const path = key ? key.split('.') : undefined;
+  const target = deep(path, lang);
+  if (target) {
+    Object.assign(target, bundle);
+  }
+};

package/lib/nextId.ts

@@ -0,0 +1,9 @@
+/**
+ * incremental Uid generation function.
+ *
+ * @returns new unique Uid
+ */
+
+let COUNTER = 1;
+
+export const nextId = (p = ''): Uid => p + COUNTER++;

package/lib/noop.ts

@@ -0,0 +1,8 @@
+/**
+ * The `identity` function.
+ *
+ * @returns input parameter `as is`
+ */
+export const noop = () => undefined;
+
+export const identity = <T = unknown>(e: T): T => e;

package/lib/obj.ts

@@ -0,0 +1,62 @@
+/**
+ * Checks if argument is empty .
+ */
+export const isEmpty = (x: unknown): boolean => {
+  if (!x) {
+    return true;
+  }
+  if (typeof x === 'object') {
+    if (x === null) {
+      return true;
+    }
+    // (zero-length array)
+    if (Array.isArray(x)) {
+      return x.length === 0;
+    }
+    // (zero-size map)
+    if (x instanceof Map) {
+      return x.size === 0;
+    }
+    // (has no props)
+    return Object.keys(x).length === 0;
+  }
+  return false;
+};
+
+// data structures
+export const dot = (x: any, k: string) => (x ? x[k] : null);
+
+export const assignKeyValue = (o: Obj, key: string, value: unknown): object => {
+  return Object.assign(o || {}, { [key]: value });
+};
+
+export const pack = (x?: unknown, key = 'value'): object => {
+  return { [key]: x };
+};
+
+export const gettus = (o: Obj, key: string | string[] | ((e: Obj) => unknown)): unknown => {
+  if (!o || !key || typeof o !== 'object') return undefined;
+  if (typeof key === 'function') return key(o);
+  if (typeof key === 'string') {
+    if (!key.includes('.')) return o[key];
+    key = key.split('.');
+  }
+  return key.reduce<Obj | undefined>((r, e) => (r ? (r[e] as Obj) : undefined), o);
+};
+
+export const settus = (o: Obj, key: string | string[] | ((e: Obj, v: unknown) => unknown), value: unknown): void => {
+  if (!o || !key || typeof o !== 'object') return;
+
+  if (typeof key === 'function') {
+    key(o, value);
+  } else {
+    const keys = typeof key === 'string' ? key.split('.') : key;
+    if (keys.length) {
+      const last = keys.pop();
+      const target = keys.reduce<Obj | undefined>((r, e) => (r ? (r[e] as Obj) : undefined), o);
+      if (last && target && typeof o === 'object') {
+        target[last] = value;
+      }
+    }
+  }
+};

package/lib/predicat.ts

@@ -0,0 +1,26 @@
+const compilePredicatChunk = (s: string): Predicat<Data> => {
+  const tokens = s.match(/(\w+)\s*(!?)=\s*([,\wа-яА-Я]+)/);
+  if (!tokens) {
+    return s[0] === '!' ? (d) => !d[s.slice(1)] : (d) => !!d[s];
+  }
+  const [_, key, neg, val] = tokens;
+  const fn = (d: Data) => val.includes(String(d[key]));
+  return neg ? (d) => !!d[key] && !fn(d) : fn;
+};
+
+const compilePredicat = (s: string | boolean): Predicat<Data> => {
+  if (!s || s === 'FALSE' || s === 'false') return () => false;
+  if (s === 'ALWAYS' || s === 'TRUE' || s === 'true' || s === true) return () => true;
+
+  const expr = String(s)
+    .split('&&')
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map(compilePredicatChunk);
+
+  return (data) => !!expr.find((fn) => fn(data));
+};
+
+const PREDICATS: Hash<Predicat<Data>> = {};
+
+export const getPredicat = (s: string | boolean = '') => PREDICATS['' + s] || (PREDICATS['' + s] = compilePredicat(s));

package/lib/resources.ru.ts

@@ -0,0 +1,20 @@
+export default {
+  monthNames: [
+    '',
+    'Январь',
+    'Февраль',
+    'Март',
+    'Апрель',
+    'Май',
+    'Июнь',
+    'Июль',
+    'Август',
+    'Сентябрь',
+    'Октябрь',
+    'Ноябрь',
+    'Декабрь',
+  ],
+  monthNamesShort: ['', 'Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июн', 'Июл', 'Авг', 'Сен', 'Окт', 'Ноя', 'Дек'],
+  dayNames: ['Воскресенье', 'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота'],
+  dayNamesShort: ['Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],
+};

package/lib/resources.ts

@@ -0,0 +1,20 @@
+export default {
+  monthNames: [
+    '',
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+  ],
+  monthNamesShort: ['', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+  dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+  dayNamesShort: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+};

package/lib/scalar.ts

@@ -0,0 +1,25 @@
+export const scalarParse = (s?: string): Scalar | undefined => {
+  if (s === 'undefined') {
+    return undefined;
+  }
+  if (s === 'null') {
+    return null;
+  }
+  if (s === 'true') {
+    return true;
+  }
+  if (s === 'false') {
+    return false;
+  }
+  if (s === '0') {
+    return 0;
+  }
+  if (s === '') {
+    return '';
+  }
+  if (s && '1234567890+-'.includes(s[0]) && s.length <= 17) {
+    const num = +s;
+    return isNaN(num) ? s : num;
+  }
+  return s;
+};

package/lib/str.ts

@@ -0,0 +1,76 @@
+export function str(x: unknown) {
+  return x == null ? '' : String(x);
+}
+
+export function capitalize(x: unknown) {
+  const s = str(x);
+  return s ? s[0].toUpperCase() + s.slice(1) : '';
+}
+
+export function camelize(x: unknown, sep = '_') {
+  return str(x)
+    .split(sep)
+    .map((t, i) => (i ? capitalize(t) : t))
+    .join('');
+}
+
+export const snakeCase = (x: string) => str(x).replace(/([a-z])([A-Z])/g, '$1_$2');
+export const properCase = (x: string) => capitalize(camelize(x));
+export const upperCase = (x: string) => str(x).toUpperCase();
+export const lowerCase = (x: string) => str(x).toLowerCase();
+
+export function strFormat(template: string, params: Hash) {
+  return str(template).replace(/\{([\S]+)\}/i, (_, key) => ((params && params[key]) != null ? str(params[key]) : ''));
+}
+
+export const strEnhance = (x: string, template: string) => {
+  return !x ? '' : `${template || '*'}`.replace('*', x);
+};
+
+export const tail = (x: string, sep = '.') => {
+  if (!x) {
+    return '';
+  }
+  const pos = x.lastIndexOf(sep);
+  return pos === -1 ? x : x.slice(pos + sep.length);
+};
+
+export const head = (x: string, sep = '.') => {
+  if (!x) {
+    return '';
+  }
+  const pos = x.indexOf(sep);
+
+  return pos === -1 ? x : x.slice(0, pos);
+};
+
+export const mirror = (x: string) =>
+  str(x)
+    .split('')
+    .reduce((r, c) => c + r, '');
+
+/* Simple hash function. */
+export const hash = (s: string) => {
+  let a = 1,
+    c = 0,
+    h,
+    o;
+  if (s) {
+    a = 0;
+    for (h = s.length - 1; h >= 0; h--) {
+      o = s.charCodeAt(h);
+      a = ((a << 6) & 268435455) + o + (o << 14);
+      c = a & 266338304;
+      a = c !== 0 ? a ^ (c >> 21) : a;
+    }
+  }
+  return String(a);
+};
+
+export function padLeft(x: string | number, size = 2, fill = '0') {
+  let s = str(x);
+  while (s.length < size) {
+    s = `${fill}${s}`;
+  }
+  return s;
+}