@pacem/pacem-core 1.0.0-abel

package/dist/esm/transforms.js

@@ -0,0 +1,248 @@
+/// <reference path="decorators.ts" />
+//namespace Pacem {
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PCSS } from './prefix';
+import { Utils } from './utils';
+import { CustomElementUtils } from './utils-customelement';
+import { Transformer } from './decorators';
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildDiffOptions(modeOrOutput, outputOrCssAdd, cssAddOrRemove, cssRemoveIfAny) {
+    let mode = 'char';
+    let output = 'full';
+    let cssAdd;
+    let cssRemove;
+    if (['line', 'word', 'char'].includes(modeOrOutput)) {
+        mode = modeOrOutput;
+        output = outputOrCssAdd;
+        cssAdd = cssAddOrRemove;
+        cssRemove = cssRemoveIfAny;
+    }
+    else {
+        output = modeOrOutput;
+        cssAdd = outputOrCssAdd;
+        cssRemove = cssAddOrRemove;
+    }
+    return {
+        mode,
+        output,
+        cssAdd: cssAdd ?? 'fill-green-container',
+        cssRemove: cssRemove ?? 'fill-red-container',
+    };
+}
+class Transforms {
+    static highlight(src, query, css = PCSS + '-highlight') {
+        if (!query || !src)
+            return src;
+        let output = src.substring(0);
+        const trunks = query.substring(0).split(' ');
+        for (var j = 0; j < trunks.length; j++) {
+            const trunk = escapeRegExp(trunks[j]);
+            const regex = new RegExp('(?![^<>]*>)' + trunk, 'gi');
+            output = output.replace(regex, function (piece, index, whole) {
+                var startTagNdx, endTagIndex;
+                if ((startTagNdx = whole.indexOf('<', index)) != (endTagIndex = whole.indexOf('</', index)) || startTagNdx == -1)
+                    return '<span class="' + css + '">' + piece + '</span>';
+                return piece;
+            });
+        }
+        return output;
+    }
+    static diff(a, b, modeOrOutput = 'full', outputOrCssAdd, cssAddOrRemove, cssRemoveIfAny) {
+        const { mode, output, cssAdd, cssRemove } = buildDiffOptions(modeOrOutput, outputOrCssAdd, cssAddOrRemove, cssRemoveIfAny);
+        const tokens = Utils.diff(a, b, mode);
+        return tokens.reduce((acc, token) => {
+            const t = token.type;
+            if (t === '=') {
+                acc += token.value;
+            }
+            else if (t === '+' && output !== 'left' || t === '-' && output !== 'right') {
+                const lines = token.value.split(/\r?\n/);
+                const lUpperBound = lines.length - 1;
+                for (let l = 0; l <= lUpperBound; l++) {
+                    const line = lines[l];
+                    if (!Utils.isNullOrEmpty(line) || l < lUpperBound) {
+                        const css = t === '-' ? cssRemove : cssAdd;
+                        acc += `<span class="${PCSS}-token ${css} text-prewrap">${line || ' '}</span>`;
+                    }
+                    if (l < lUpperBound) {
+                        acc += '\n';
+                    }
+                }
+            }
+            return acc;
+        }, '');
+    }
+    static padleft(src, length, pad) {
+        return Utils.leftPad('' + src, length, pad);
+    }
+    static size(src) {
+        // TODO: use logarithms
+        if (!(src > 0))
+            return '-';
+        if (src < 1024 /* 1kB */)
+            return src + ' B';
+        if (src < 1_048_576 /* 1MB */)
+            return (src / 1024).toFixed(2) + ' kB';
+        if (src < 1_073_741_824 /* 1GB */)
+            return (src / 1_048_576).toFixed(2) + ' MB';
+        return (src / 1_073_741_824).toFixed(2) + ' GB';
+    }
+    static decToDeg(src, degSeparator = '° ', minSeparator = '\' ', secSeparator = '"') {
+        const sign = Math.sign(src);
+        src = Math.abs(src);
+        const deg = Math.floor(src), min0 = (src - deg) * 60, min = Math.floor(min0), sec0 = (min0 - min) * 60, sec = Math.floor(sec0);
+        return (sign < 0 ? '-' : '') + deg + degSeparator + min + minSeparator + sec + secSeparator;
+    }
+    static date(src, format, culture) {
+        var date = Utils.parseDate(src), lang = culture || navigator.language;
+        if (Utils.isNull(format) || typeof format === 'string') {
+            switch (format) {
+                case 'iso':
+                    return date.toISOString();
+                case 'isodate':
+                    return date.toISOString().substring(0, 10);
+                case 'localdate':
+                    return `${date.getFullYear()}-${Utils.leftPad(date.getMonth() + 1, 2, '0')}-${Utils.leftPad(date.getDate(), 2, '0')}`;
+                case 'time':
+                case 'localtime':
+                    return date.toLocaleTimeString(lang, { hour: 'numeric', minute: 'numeric', second: 'numeric', hour12: false });
+                case 'full':
+                    const offset = -(date.getTimezoneOffset() / 60);
+                    var utc = '';
+                    if (offset != 0)
+                        utc = ' (UTC' + ((offset > 0 ? '+' : '-') + Math.abs(offset).toLocaleString()) + ')';
+                    return date.toLocaleString(lang) + utc;
+                default:
+                    return date.toLocaleDateString(lang);
+            }
+        }
+        else {
+            return date.toLocaleString(culture, format);
+        }
+    }
+    static timespan(start, end, format, culture) {
+        const startDate = Utils.parseDate(start), endDate = Utils.parseDate(end), span = endDate.valueOf() - startDate.valueOf(), sign = span < 0 ? '-' : '', elapsed = Math.abs(span);
+        if (typeof format === 'object') {
+            const adj = { timeZone: 'UTC', hour12: false }, tweakedFormat = Utils.extend(adj, format);
+            return (sign || (format.sign ? '+' : '')) + Intl.DateTimeFormat(culture ?? navigator.language, tweakedFormat).format(elapsed);
+        }
+        // legacy output
+        const msecsPerDay = 86400000, msecsPerHr = 3600000, msecsPerMin = 60000, days = Math.floor(elapsed / msecsPerDay), hrs = Math.floor((elapsed % msecsPerDay) / msecsPerHr), mins = Math.floor((elapsed % msecsPerHr) / msecsPerMin), secs = Math.floor((elapsed % msecsPerMin) / 1000), msecs = Math.floor(elapsed % 1000);
+        return `${sign}${days}d ${hrs}h ${mins}m ${secs}s ${msecs}ms`;
+    }
+    static currency(src, currency, culture) {
+        return new Intl.NumberFormat(culture ?? navigator.language, { style: 'currency', currency: currency }).format(src);
+    }
+    static number(src, formatOrCulture, culture) {
+        if (typeof formatOrCulture === 'string') {
+            return new Intl.NumberFormat(formatOrCulture || navigator.language).format(src);
+        }
+        return new Intl.NumberFormat(culture ?? navigator.language, formatOrCulture).format(src);
+    }
+    static filter(src, filter) {
+        return src.filter(filter);
+    }
+    static orderby(src, prop) {
+        return src.sort((a, b) => {
+            if (!Utils.isNullOrEmpty(prop)) {
+                a = a[prop];
+                b = b[prop];
+            }
+            return a > b ? 1 : (a < b ? -1 : 0);
+        });
+    }
+    // #region RegExp
+    static isMatch(input, pattern, flags) {
+        return new RegExp(pattern, flags).test(input);
+    }
+    // #endregion
+    // #region shortcuts from 'Utils'
+    static isEmpty(obj) {
+        return Utils.isEmpty(obj);
+    }
+    static isNull(obj) {
+        return Utils.isNull(obj);
+    }
+    static isNullOrEmpty(obj) {
+        return Utils.isNullOrEmpty(obj);
+    }
+    static getCssVariable(name) {
+        return Utils.Css.getVariableValue(name);
+    }
+    static getQuerystring(name) {
+        return Utils.URIs.parseQuery()[name];
+    }
+    // #endregion
+    // #region shortcuts from 'CustomElementUtils'
+    static importThemeWebFonts() {
+        return CustomElementUtils.Theme.importWebFonts();
+    }
+    static findHostContext(element) {
+        return CustomElementUtils.findHostContext(element);
+    }
+}
+__decorate([
+    Transformer()
+], Transforms, "highlight", null);
+__decorate([
+    Transformer()
+], Transforms, "diff", null);
+__decorate([
+    Transformer()
+], Transforms, "padleft", null);
+__decorate([
+    Transformer()
+], Transforms, "size", null);
+__decorate([
+    Transformer()
+], Transforms, "decToDeg", null);
+__decorate([
+    Transformer()
+], Transforms, "date", null);
+__decorate([
+    Transformer()
+], Transforms, "timespan", null);
+__decorate([
+    Transformer()
+], Transforms, "currency", null);
+__decorate([
+    Transformer()
+], Transforms, "number", null);
+__decorate([
+    Transformer()
+], Transforms, "filter", null);
+__decorate([
+    Transformer()
+], Transforms, "orderby", null);
+__decorate([
+    Transformer('regex.')
+], Transforms, "isMatch", null);
+__decorate([
+    Transformer()
+], Transforms, "isEmpty", null);
+__decorate([
+    Transformer()
+], Transforms, "isNull", null);
+__decorate([
+    Transformer()
+], Transforms, "isNullOrEmpty", null);
+__decorate([
+    Transformer('cssvar')
+], Transforms, "getCssVariable", null);
+__decorate([
+    Transformer('querystring')
+], Transforms, "getQuerystring", null);
+__decorate([
+    Transformer()
+], Transforms, "importThemeWebFonts", null);
+__decorate([
+    Transformer('host')
+], Transforms, "findHostContext", null);
+//}

package/dist/esm/types.js

@@ -0,0 +1,10 @@
+/// <reference path="events.ts" />
+export const Type = Function;
+;
+// #region CONSTS
+export const WATCH_PROPS_VAR = 'pacem:properties';
+export const INSTANCE_BINDINGS_VAR = 'pacem:custom-element:bindings';
+export const INSTANCE_HOST_VAR = 'pacem:custom-element:host';
+export const INSTANCE_SCOPE_VAR = 'pacem:custom-element:scope';
+// #endregion
+//}