arrmatura 5.0.4 → 5.2.0

package/lib/{arrayGroupBy.ts → array/arrayGroupBy.ts}

@@ -1,4 +1,4 @@
-import { gettus } from 'obj';
+import { gettus } from '../object';
 
 type GroupOf<T> = { id: string; count: number; items: T[] };
 

package/lib/{arraySortBy.ts → array/arraySortBy.ts}

@@ -25,8 +25,8 @@ const sortByComparator = <T extends Comparable>(
       key = fn.substr(1);
     }
     return (a: T, b: T): ComparatorResult => {
-      const aa = a[fn];
-      const bb = b[fn];
+      const aa = a[key];
+      const bb = b[key];
       return aa < bb ? negOrder : aa > bb ? order : 0;
     };
   }
@@ -40,10 +40,10 @@ const sortByComparator = <T extends Comparable>(
 /**
  * Sorts array by element property
  */
-export const arraySortBy = function sortBy(
-  arr: Comparable[],
+export const arraySortBy = function sortBy<T extends Comparable>(
+  arr: T[],
   property = 'name',
   order: ComparatorDirection = ComparatorDirection.ASC
 ) {
-  return (arr || []).slice(0).sort(sortByComparator(property, order));
+  return !arr ? [] : [...arr].sort(sortByComparator<T>(property, order));
 };

package/lib/array/arrayish.ts

@@ -0,0 +1,7 @@
+// arrayish:
+export const includes = (x: any, p: string) => x?.includes?.(p);
+export const slice = <T>(x: T[], b = 0, e?: number): T[] => x?.slice?.(b, e) || [];
+export const split = (x: string, key = ' ') => x?.split?.(key) || [];
+export const find = <T extends Hash<any>>(x: T[], val: unknown, key = 'id') => x?.find?.((e: T) => e[key] == val);
+export const filter = <T extends Hash<any>>(x: T[], key: string, val: unknown) =>
+  x?.filter?.((e: T) => !e[key] || e[key] == val);

package/lib/array/index.ts

@@ -0,0 +1,4 @@
+export * from './arrayGroupBy';
+export { arraySortBy } from './arraySortBy';
+export * from './arrayToObject';
+export * from './arrayish';

package/lib/crypto/index.ts

@@ -0,0 +1,25 @@
+/* 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()}`;
+
+/* 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);
+};

package/lib/{dateFormat.ts → date/index.ts}

@@ -1,6 +1,5 @@
-import { dateOf } from 'dateOf';
-import { t } from 'l10n';
-import { padLeft } from 'str';
+import { t } from '../resources/l10n';
+import { padLeft } from 'string';
 
 export const daysInMonth = (month: number, year: number) => new Date(year, month + 1, 0).getDate();
 
@@ -53,6 +52,33 @@ export function setDefaultDateFormat(f: string) {
   DEFAULT_DATE_FORMAT = f;
 }
 
+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);
+};
 export const dateFormat = (x: Dateable | null, format = DEFAULT_DATE_FORMAT) => {
   if (!x) {
     return '';
@@ -67,3 +93,35 @@ export const dateFormat = (x: Dateable | null, format = DEFAULT_DATE_FORMAT) =>
         return key;
       });
 };
+
+/**
+ * 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;
+}
+
+export const date = (x: any) => dateFormat(dateOf(x));

package/lib/func/curry.ts

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

package/lib/{fx.ts → func/fx.ts}

@@ -1,35 +1,11 @@
 /**
- * Functions
+ * Useful low-level 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 isNotANumber = (x: any) => isNaN(x);
 export const isUndefined = <T = unknown>(x: T): boolean => typeof x === 'undefined';
 
 // logical
@@ -41,22 +17,40 @@ 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 equals = (x: any, p: any, thenn: any = true, elsee: any = false) => (x == p ? thenn : elsee);
+export const greater = (x: any, p: any, thenn: any = true, elsee: any = false) => (x > p ? thenn : elsee);
+export const less = (x: any, p: any, thenn: any = true, elsee: any = false) => (x < p ? thenn : elsee);
+export const min = Math.min;
+export const max = Math.max;
 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 =
+// functions
+export const fnBindArgs = (fn: () => unknown, ...args: never[]) => fn?.bind(null, ...args);
+
+export const fnCall = (fn: any, ...args: number[]) => {
+  return fn(...args);
+};
+
+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 fnTick = (fn: any, lag: number) => {
+  return () => setTimeout(fn, lag);
+};
+
+export const fnSwapArgs = (f: BinaryOp) => (a: unknown, b: unknown) => f(b, a);
+
+export const fnCompose =
   (...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/{noop.ts → func/identity.ts}

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

package/lib/func/noop.ts

@@ -0,0 +1,6 @@
+/**
+ * The `noop/Dzirka` function.
+ *
+ * @returns undefined
+ */
+export const noop = () => undefined;

package/lib/geo/index.js

@@ -0,0 +1,22 @@
+
+/* eslint-disable max-statements */
+export const calculateDistance = (_lat1, _long1, _lat2, _long2) => {
+    const R = 6372795;
+    const lat1 = (_lat1 * Math.PI) / 180;
+    const lat2 = (_lat2 * Math.PI) / 180;
+    const long1 = (_long1 * Math.PI) / 180;
+    const long2 = (_long2 * Math.PI) / 180;
+    const cl1 = Math.cos(lat1);
+    const cl2 = Math.cos(lat2);
+    const sl1 = Math.sin(lat1);
+    const sl2 = Math.sin(lat2);
+    const delta = long2 - long1;
+    const cdelta = Math.cos(delta);
+    const sdelta = Math.sin(delta);
+    const y = Math.sqrt(((cl2 * sdelta) ** 2) + (((cl1 * sl2) - (sl1 * cl2 * cdelta)) ** 2));
+    const x = (sl1 * sl2) + (cl1 * cl2 * cdelta);
+    const ad = Math.atan2(y, x);
+    const distance = (ad * R) / 1000;
+    /* eslint-disable no-restricted-globals */
+    return isNaN(distance) ? -1 : Number(distance.toFixed(2));
+};

package/lib/index.ts

@@ -1,19 +1,17 @@
-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';
+export * from './array';
+export * from './date';
+export * from './crypto';
+export * from './resources/l10n';
+export * from './func/nextId';
+export * from './func/curry';
+export * from './func/noop';
+export * from './func/identity';
+export * from './func/fx';
+export * from './object';
+export * from './string';
+export * from './parsing/scalarParse';
+export * from './parsing/codus';
+export * from './parsing/compiler';
+export * from './parsing/urls';
+export * from './parsing/xml';
+export * from './support/createListeners';

package/lib/{obj.ts → object/index.ts}

@@ -24,14 +24,19 @@ export const isEmpty = (x: unknown): boolean => {
 };
 
 // data structures
-export const dot = (x: any, k: string) => (x ? x[k] : null);
-export const keysOf = (x: any) => x ? Object.keys(x) : null;
-export const valuesOf = (x: any) => x ? Object.keys(x ): null;
+export const dot = (x: any, k: string = 'name') => (x ? x[k] : null);
+export const keysOf = (x: any) => (x ? Object.keys(x) : null);
+export const valuesOf = (x: any) => (x ? Object.keys(x) : null);
 
 export const assignKeyValue = (o: Obj, key: string, value: unknown): object => {
   return Object.assign(o || {}, { [key]: value });
 };
 
+export const assignFirstArgKeyValue =
+  (fn: (...args: unknown[]) => unknown, key: string, val: unknown) =>
+  (x: object, ...args: unknown[]) =>
+    fn.call(null, Object.assign(x || {}, { [key]: val }), ...args.slice(1));
+
 export const pack = (x?: unknown, key = 'value'): object => {
   return { [key]: x };
 };

package/lib/{codus.ts → parsing/codus.ts}

@@ -1,4 +1,4 @@
-import { scalarParse } from 'scalar';
+import { scalarParse } from './scalarParse';
 
 export const decodus = (val: string): unknown => {
   if (!val) return undefined;

package/lib/{xml.ts → parsing/xml.ts}

@@ -1,4 +1,4 @@
-import { scalarParse } from './scalar';
+import { scalarParse } from './scalarParse';
 
 const RE_ATTRS = /([a-z][a-zA-Z0-9-:]+)(="[^"]*"|={[^}]*})?/g;
 const RE_EMPTY = /^\s*$/;
@@ -6,7 +6,7 @@ const RE_XML_COMMENT = /<!--((?!-->)[\s\S])*-->/g;
 const RE_XML_TAG = /(<)(\/?)([a-zа-я][a-zа-я0-9-:]*)((?:\s+[a-z][a-z0-9-:]+(?:="[^"]*"|={[^}]*})?)*)\s*(\/?)>/gi;
 const SINGLE_TAGS = { img: 1, input: 1, br: 1, col: 1 };
 
-const RE_XML_ENTITY = /&#?[0-9a-z]{3,5};/g;
+const RE_XML_ENTITY = /&#?[0-9a-z]{2,5};/g;
 
 const SUBST_XML_ENTITY: Record<string, string> = {
   amp: '&',
@@ -34,7 +34,7 @@ const FN_XML_ENTITY = function (s0: string) {
 
 export const skipQoutes = (s: string) => (s[0] === '"' && s[s.length - 1] === '"' ? s.slice(1, -1) : s);
 
-export const decodeXmlEntities = (s = '') => s.replace(RE_XML_ENTITY, FN_XML_ENTITY);
+export const decodeXmlEntities = (s?: string) => String(s || '').replace(RE_XML_ENTITY, FN_XML_ENTITY);
 
 const addNode = (c: XmlNode, tag: string) => {
   const node: XmlNode = { tag };

package/lib/{l10n.ts → resources/l10n.ts}

@@ -1,5 +1,5 @@
-import en from 'resources';
-import ru from 'resources.ru';
+import en from './resources';
+import ru from './resources.ru';
 
 const R = { en, ru };
 

package/lib/{str.ts → string/index.ts}

@@ -27,7 +27,7 @@ export const strEnhance = (x: string, template: string) => {
   return !x ? '' : `${template || '*'}`.replace('*', x);
 };
 
-export const tail = (x: string, sep = '.') => {
+export const tail = (x: string, sep = ' ') => {
   if (!x) {
     return '';
   }
@@ -35,7 +35,7 @@ export const tail = (x: string, sep = '.') => {
   return pos === -1 ? x : x.slice(pos + sep.length);
 };
 
-export const head = (x: string, sep = '.') => {
+export const head = (x: string, sep = ' ') => {
   if (!x) {
     return '';
   }
@@ -49,24 +49,6 @@ export const mirror = (x: string) =>
     .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) {

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "arrmatura",
-  "version": "5.0.4",
-  "description": "framework",
+  "version": "5.2.0",
+  "description": "reactive web ui framework",
   "scripts": {
-    "start": "npx webpack-dev-server --hot --contentBase docs",
-    "build": "npx webpack-cli --mode production && cp -fv docs/quiz.js public",
-    "deploy:host": "firebase use ${NODE_ENV:-default} && firebase deploy --only hosting",
-    "release": "npx webpack-cli && npm publish"
+    "start": "npx webpack-dev-server --hot --contentBase docs --config webpack.config.js",
+    "build": "npx webpack-cli --mode production",
+    "serve": "npx http-server ./docs",
+    "release": "npx webpack-cli && npm publish",
+    "pull": "./tools/pull.sh"
   },
   "repository": {
     "type": "git",

package/commons/forms/ItemCollection.ts

@@ -1,152 +0,0 @@
-import { Service } from '../services/Service';
-import { analyzeDataByTags, getSuggestions, Item } from './Item';
-import { arraySortBy } from 'arraySortBy';
-
-export class ItemCollection extends Service {
-  selection: Hash = {};
-  shownLimit = 50;
-  sortBy = '-ts';
-  kluqPoshuku = '';
-  data?: Item[];
-  inputKluqPoshuku: any;
-  newEntry: any;
-  entry: any;
-  initials = '';
-
-  setData(data: Hash[]) {
-    this.data = !data ? [] : data.filter((e) => e.status !== 'deleted').map((e) => new Item(e));
-  }
-
-  getInfo() {
-    if (!this.data) {
-      return {};
-    }
-    const searchedData = !this.kluqPoshuku
-      ? this.data
-      : this.data.filter((e) => e.$searchData.includes(this.kluqPoshuku));
-    const { actualData, tags } = analyzeDataByTags(searchedData, this.selection, this.initials);
-    const sortedData = arraySortBy(actualData, this.sortBy);
-    return {
-      tags: tags.sort((a, b) => (a.selected === b.selected ? (a.id > b.id ? 1 : -1) : !a.selected ? 1 : -1)),
-      data: sortedData.slice(0, this.shownLimit),
-      openEntry: ({ id }) =>
-        this.emit(
-          'this.openEntry',
-          this.data?.find((e) => e.id === id)
-        ),
-      counts: {
-        total: this.data.length,
-        actual: actualData.length,
-        hasMore: this.shownLimit < actualData.length,
-      },
-      search: {
-        kluq: this.kluqPoshuku,
-        value: this.inputKluqPoshuku,
-        suggestions:
-          this.kluqPoshuku === this.inputKluqPoshuku ? null : getSuggestions(this.data, this.inputKluqPoshuku),
-        input: (data) => this.emit('this.inputKluq', data),
-        enter: (data) => this.emit('this.znajdzPoKluqu', data),
-      },
-    };
-  }
-
-  onTag({ id }, { selection }: this) {
-    return {
-      selection: !id
-        ? {}
-        : {
-            ...selection,
-            [id]: !selection[id],
-          },
-    };
-  }
-
-  onZnajdzPoKluqu({ value }) {
-    return {
-      inputKluqPoshuku: value || '',
-      kluqPoshuku: value || '',
-    };
-  }
-  onInputKluq({ value }) {
-    return {
-      inputKluqPoshuku: value || '',
-    };
-  }
-  onSortBy({ value }) {
-    return {
-      sortBy: value || '-ts',
-    };
-  }
-  onShowMore({ size = 50 }, { shownLimit = 50 }) {
-    return {
-      shownLimit: shownLimit + size,
-    };
-  }
-  /**
-   * New Entry
-   */
-
-  onOpenAddNew(data) {
-    return {
-      newEntry: {
-        ...data,
-        ...this.newEntry,
-        cancel: () => this.emit('this.cancelAddNew'),
-        submit: (data) => this.emit('this.saveNew', data),
-        open: true,
-      },
-    };
-  }
-
-  onCancelAddNew() {
-    return {
-      newEntry: { ...this.newEntry, open: false },
-    };
-  }
-
-  async onSaveNew(data) {
-    delete data.id;
-    await this.upsert(data);
-    return {
-      newEntry: { ...this.newEntry, data, open: false },
-    };
-  }
-  upsert(data: any) {
-    throw new Error('Method not implemented.');
-  }
-  /**
-   * Entry
-   */
-
-  onOpenEntry(data) {
-    return {
-      entry: {
-        id: data.id,
-        data: Object.entries(data).reduce((r, [k, v]) => {
-          if (k[0] !== '$') {
-            r[k] = v;
-          }
-          return r;
-        }, {}),
-        ...this.entry,
-        cancel: () => this.emit('this.cancelEntry'),
-        submit: (data) => this.emit('this.saveEntry', data),
-        delete: () => this.emit('this.deleteEntry', { id: data.id }),
-        open: true,
-      },
-    };
-  }
-
-  onCancelEntry() {
-    return { entry: { open: false } };
-  }
-
-  async onSaveEntry(data) {
-    await this.upsert(data);
-    return { entry: { open: false } };
-  }
-  async onDeleteEntry(data) {
-    await this.upsert({ ...data, status: 'deleted' });
-    return { entry: { open: false } };
-  }
-}