arrmatura 4.2.2 → 5.0.2

package/lib/urls.ts

@@ -0,0 +1,91 @@
+/**
+ * Parses string into Url object.
+ */
+export const urlParse = (_s: string): Url => {
+  const r: Url = { path: [], params: {}, host: '' };
+  if (!_s) {
+    return r;
+  }
+  let p: number;
+  let s = _s;
+  // extract type:
+  p = s.indexOf(':');
+  if (p > -1) {
+    r.protocol = s.slice(0, p);
+    s = s.slice(p + 1);
+  }
+  // extract hash:
+  p = s.indexOf('#');
+  if (p > -1) {
+    r.hash = decodeURIComponent(s.slice(p + 1));
+    s = s.slice(0, p);
+  }
+  // extract query params:
+  p = s.indexOf('?');
+  if (p > -1) {
+    s.slice(p + 1)
+      .replace(/\+/g, ' ')
+      .split('&')
+      .forEach((param) => {
+        const [key, value] = param.split('=');
+        if (value) {
+          r.params[decodeURIComponent(key)] = decodeURIComponent(value);
+        }
+      });
+    s = s.slice(0, p);
+  }
+  // host and path:
+  r.path = s.split('/').map(decodeURIComponent);
+  const path = r.path;
+  if (path.length > 2 && !path[0] && !path[1]) {
+    path.shift();
+    path.shift();
+    r.host = path.shift() || '';
+  }
+
+  return r;
+};
+
+/**
+ *  Represents an Url object as a string
+ *
+ * @param {object} r Url object like `{type, host, path, params, hash }`
+ * @returns string in format `type:host/path?params#hash`
+ */
+export const urlStringify = (r: Url): string => {
+  let result = '';
+  if (!r) {
+    return result;
+  }
+  if (r.host) {
+    if (r.protocol) {
+      result += `${r.protocol}:`;
+    }
+    result += `//${r.host}`;
+  }
+  if (r?.path.length) {
+    result += `/${r.path.map(encodeURIComponent).join('/')}`;
+  }
+  const { params } = r;
+
+  const keys = Object.keys(params).filter((key) => params[key] != null);
+  if (keys.length) {
+    result += `?${keys
+      .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+      .join('&')}`.replace(/ /g, '+');
+  }
+
+  if (r.hash) {
+    result += `${r.hash[0] === '#' ? '' : '#'}${encodeURIComponent(r.hash)}`;
+  }
+
+  return result;
+};
+
+export const urlAppendParams = (url: string = '', params: UrlParams = {}): string => {
+  const queryString = Object.entries(params)
+    ?.map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+    .join('&');
+
+  return [url, queryString].filter(Boolean).join(url.includes('?') ? '&' : '?');
+};

package/lib/xml.ts

@@ -0,0 +1,117 @@
+import { scalarParse } from './scalar';
+
+const RE_ATTRS = /([a-z][a-zA-Z0-9-:]+)(="[^"]*"|={[^}]*})?/g;
+const RE_EMPTY = /^\s*$/;
+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 SUBST_XML_ENTITY: Record<string, string> = {
+  amp: '&',
+  gt: '>',
+  lt: '<',
+  quot: '"',
+  nbsp: ' ',
+};
+
+const ESCAPE_XML_ENTITY: Record<string, string> = {
+  34: '&quot;',
+  38: '&amp;',
+  39: '&#39;',
+  60: '&lt;',
+  62: '&gt;',
+};
+const RE_ESCAPE_XML_ENTITY = /["'&<>]/g;
+
+const FN_ESCAPE_XML_ENTITY = (m: string) => ESCAPE_XML_ENTITY[m.charCodeAt(0)];
+
+const FN_XML_ENTITY = function (s0: string) {
+  const s = s0.substring(1, s0.length - 1);
+  return s[0] === '#' ? String.fromCharCode(+s.slice(1)) : SUBST_XML_ENTITY[s] || ' ';
+};
+
+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);
+
+const addNode = (c: XmlNode, tag: string) => {
+  const node: XmlNode = { tag };
+  (c.nodes || (c.nodes = [])).push(node);
+
+  return node;
+};
+
+const parseAttrs = (node: XmlNode, s: string) => {
+  if (!s) return;
+  node.attrs = {};
+  for (let e = RE_ATTRS.exec(s); e; e = RE_ATTRS.exec(s)) {
+    const value = !e[2] ? true : scalarParse(decodeXmlEntities(skipQoutes(e[2].slice(1))));
+    node.attrs[e[1]] = value;
+  }
+};
+
+export const escapeXml = (s: string) => (!s ? '' : ('' + s).replace(RE_ESCAPE_XML_ENTITY, FN_ESCAPE_XML_ENTITY));
+
+export const attributesToString = (v?: Hash): string | undefined => {
+  if (typeof v === 'object') {
+    if (Array.isArray(v)) {
+      return !v.length ? '[]' : '[' + attributesToString(v[0]) + ' x' + v.length + ']';
+    }
+    return '{' + Object.keys(v).toString() + '}';
+  }
+  return v;
+};
+
+export function xmlStringify({ tag, attrs, nodes = [] }: XmlNode, tab = ''): string {
+  if (tag === '#text') {
+    return `${tab}${escapeXml(String(attrs?.text || ''))}`;
+  }
+  const sattrs = attributesToString(attrs);
+  const ssubs = nodes.map((c) => xmlStringify(c, `  ${tab}`)).join('\n');
+
+  return `${tab}<${tag}${sattrs}` + (!ssubs ? '/>' : `>\n${ssubs}\n${tab}</${tag}>`);
+}
+
+export const xmlParse = (_s?: string): XmlNode[] => {
+  const ctx: XmlNode[] = [{ tag: '#root' }];
+  const s = String(_s).trim().replace(RE_XML_COMMENT, '');
+  let lastIndex = 0;
+  // head text omitted
+  for (let e = RE_XML_TAG.exec(s); e; e = RE_XML_TAG.exec(s)) {
+    // preceding text
+    const text = e.index && s.slice(lastIndex, e.index);
+    if (text && !text.match(RE_EMPTY)) {
+      const node = addNode(ctx[0], '#text');
+      node.attrs = { text: decodeXmlEntities(text) };
+    }
+    // closing tag
+    if (e[2]) {
+      if (ctx[0].tag !== e[3]) {
+        throw new Error(
+          ' XML Parse closing tag does not match at: ' +
+            e.index +
+            ' near ' +
+            e.input.slice(Math.max(e.index - 150, 0), e.index) +
+            '^^^^' +
+            e.input.slice(e.index, Math.min(e.index + 150, e.input.length))
+        );
+      }
+      ctx.shift();
+    } else {
+      const elt = addNode(ctx[0], e[3]);
+      parseAttrs(elt, e[4].trim());
+      // not single tag
+      if (!(e[5] || e[3] in SINGLE_TAGS)) {
+        ctx.unshift(elt);
+        if (ctx.length === 1) {
+          throw new Error('Parse error at: ' + e[0]);
+        }
+      }
+    }
+    lastIndex = RE_XML_TAG.lastIndex;
+  }
+  // tail text omitted
+  return ctx[0].nodes || [];
+};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "arrmatura",
-  "version": "4.2.2",
+  "version": "5.0.2",
   "description": "framework",
   "scripts": {
     "start": "npx webpack-dev-server --hot --contentBase docs",
-    "build": "npx webpack-cli",
+    "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"
   },
   "repository": {
@@ -15,22 +16,30 @@
   "license": "MIT",
   "main": "docs/index.js",
   "files": [
-    "commons/index.css",
-    "docs/index.js",
-    "docs/index.js.map"
+    "lib",
+    "core",
+    "core-web",
+    "commons"
   ],
   "devDependencies": {
     "@babel/cli": "^7.12.1",
     "@babel/core": "^7.12.3",
     "@babel/preset-env": "^7.12.1",
     "babel-loader": "^8.2.1",
-    "eslint": "^6.8.0",
-    "eslint-config-standard": "^14.1.1",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "eslint": "^7.30.0",
+    "@typescript-eslint/eslint-plugin": "^2.27.0",
+    "@typescript-eslint/parser": "^2.27.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "eslint-plugin-jest": "^23.18.0",
+    "eslint-plugin-react": "^7.20.3",
+    "eslint-plugin-react-hooks": "^4.0.5",
     "eslint-plugin-import": "^2.22.1",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.1.0",
+    "metro-react-native-babel-preset": "^0.66.2",
     "raw-loader": "^4.0.2",
+    "typescript": "^4.4.4",
     "webpack": "^4.44.2",
     "webpack-cli": "^3.3.12",
     "webpack-dev-server": "^3.11.0"