@based/schema 3.1.0 → 3.2.0

package/README.md

@@ -1,21 +1,2 @@
-# @based/functions
+# @based/schema
 
-To be used with based cloud functions, adds types and utilities.
-
-- Example based function
-
-```typescript
-import { BasedFunction } from '@based/functions'
-
-const submitVote: BasedFunction<
-  { target: number },
-  'ok' | 'not-ok'
-> = async (based, { target }) => {
-  if (target > 10) {
-    return 'ok'
-  }
-  return 'not-ok'
-}
-
-export default submitVote
-```

package/dist/display/index.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchemaField } from '../types';
+export declare const display: (value: string | number | void, field: BasedSchemaField) => string | number | void;

package/dist/display/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.display = void 0;
+const timestamp_1 = __importDefault(require("./timestamp"));
+const number_1 = __importDefault(require("./number"));
+const string_1 = __importDefault(require("./string"));
+const display = (value, field) => {
+    if (field.type === 'timestamp' && typeof value === 'number') {
+        // @ts-ignore
+        return (0, timestamp_1.default)(value, field.display);
+    }
+    if (field.type === 'number' && typeof value === 'number') {
+        // @ts-ignore
+        return (0, number_1.default)(value, field.display);
+    }
+    if (field.type === 'string' && typeof value === 'string') {
+        // @ts-ignore
+        return (0, string_1.default)(value, field.display);
+    }
+    return value;
+};
+exports.display = display;
+//# sourceMappingURL=index.js.map

package/dist/display/number.d.ts

@@ -0,0 +1,3 @@
+export type NumberFormat = 'short' | 'human' | 'ratio' | 'bytes' | 'euro' | 'dollar' | 'pound' | `round-${number}`;
+declare const parseNumber: (nr: number | string, format?: NumberFormat) => string | number;
+export default parseNumber;

package/dist/display/number.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseNumber = (nr, format) => {
+    if (!format) {
+        return nr;
+    }
+    if (typeof nr === 'number') {
+        if (format === 'euro' || format === 'dollar' || format === 'pound') {
+            const p = String(parseNumber(nr, 'short'));
+            const fraction = format === 'euro' ? ',' : '.';
+            const [s, f] = p.split('.');
+            return `${format === 'euro'
+                ? '€'
+                : format === 'pound'
+                    ? '£'
+                    : format === 'dollar'
+                        ? '$'
+                        : ''}${s}${f ? `${fraction}${f}` : ''}`;
+        }
+        else if (format.startsWith('round-')) {
+            const [, fixed] = format.split('round-');
+            const n = Number(fixed);
+            if (!n) {
+                return `${nr.toFixed()}`;
+            }
+            return `${nr.toFixed(n)}`;
+        }
+        else if (format === 'bytes') {
+            const kb = nr / 1024;
+            const mb = kb / 1024;
+            const gb = mb / 1024;
+            if (gb >= 1) {
+                return `${gb.toFixed(2)} gb`;
+            }
+            else if (mb >= 1) {
+                return `${mb.toFixed(2)} mb`;
+            }
+            else if (kb >= 1) {
+                return `${kb.toFixed(2)} kb`;
+            }
+            else {
+                return `${nr} ${nr === 1 ? 'byte' : 'bytes'}`;
+            }
+        }
+        else if (format === 'ratio') {
+            return `${Math.round(nr * 10000) / 100}%`;
+        }
+        else if (format === 'short') {
+            if (nr >= 10e9) {
+                nr = nr / 1e9;
+                nr = nr.toFixed(1);
+                if (nr[nr.length - 1] === '0') {
+                    nr = nr.slice(0, -2);
+                }
+                return nr + 'b';
+            }
+            else if (nr >= 10e6) {
+                nr = nr / 1e6;
+                nr = nr.toFixed(1);
+                if (nr[nr.length - 1] === '0') {
+                    nr = nr.slice(0, -2);
+                }
+                return nr + 'm';
+            }
+            else if (nr >= 10e3) {
+                nr = nr / 1e3;
+                nr = nr.toFixed(1);
+                if (nr[nr.length - 1] === '0') {
+                    nr = nr.slice(0, -2);
+                }
+                return nr + 'k';
+            }
+            nr = nr.toFixed(2);
+            if (nr[nr.length - 1] === '0') {
+                nr = nr.slice(0, -3);
+            }
+            return String(nr);
+        }
+        else if (format === 'human') {
+            return nr.toFixed(2);
+        }
+        return String(nr);
+    }
+    else {
+        return nr;
+    }
+};
+exports.default = parseNumber;
+//# sourceMappingURL=number.js.map

package/dist/display/string.d.ts

@@ -0,0 +1,3 @@
+export type StringFormat = 'lowercase' | 'uppercase' | 'capitalize';
+declare const parseString: (value?: string, format?: StringFormat) => string;
+export default parseString;

package/dist/display/string.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseString = (value, format) => {
+    if (!format) {
+        return value;
+    }
+    if (!value) {
+        return value;
+    }
+    if (format === 'lowercase') {
+        return value.toLowerCase();
+    }
+    if (format === 'uppercase') {
+        return value.toUpperCase();
+    }
+    if (format === 'capitalize') {
+        const a = value[0];
+        return a.toUpperCase() + (value ? value.slice(1) : '');
+    }
+    return value;
+};
+exports.default = parseString;
+//# sourceMappingURL=string.js.map

package/dist/display/timestamp.d.ts

@@ -0,0 +1,3 @@
+export type DateFormat = 'date' | 'date-time' | 'date-time-text' | 'human' | 'time' | 'time-precise';
+declare const _default: (nr: number | string, format?: DateFormat) => string | number;
+export default _default;

package/dist/display/timestamp.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addZero = (d) => {
+    const s = d + '';
+    if (s.length === 1) {
+        return '0' + s;
+    }
+    return s;
+};
+exports.default = (nr, format) => {
+    if (!format) {
+        return nr;
+    }
+    if (typeof nr === 'number') {
+        const thenDate = new Date(nr);
+        if (format === 'date') {
+            return (thenDate.getDate() +
+                '/' +
+                (thenDate.getMonth() + 1) +
+                '/' +
+                thenDate.getFullYear());
+        }
+        else if (format === 'time') {
+            return thenDate.getHours() + ':' + addZero(thenDate.getMinutes());
+        }
+        else if (format === 'time-precise') {
+            return (thenDate.getHours() +
+                ':' +
+                addZero(thenDate.getMinutes()) +
+                ':' +
+                addZero(thenDate.getSeconds()));
+        }
+        else if (format === 'date-time-text') {
+            return `${thenDate.toLocaleDateString('default', {
+                day: 'numeric',
+                month: 'long',
+                year: 'numeric',
+            })}, ${thenDate.toLocaleTimeString()}`;
+        }
+        else if (format === 'date-time') {
+            return (thenDate.getHours() +
+                ':' +
+                addZero(thenDate.getMinutes()) +
+                ' ' +
+                thenDate.getDate() +
+                '/' +
+                (thenDate.getMonth() + 1) +
+                '/' +
+                thenDate.getFullYear());
+        }
+        else if (format === 'human') {
+            const nowDate = new Date();
+            if (nowDate.getTime() > thenDate.getTime()) {
+                var secondsSince = Math.floor((nowDate.getTime() - thenDate.getTime()) / 1000);
+                var interval = secondsSince / 31536000; // seconds in a year
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'years' : 'year'} ago`;
+                }
+                interval = secondsSince / 2592000; // seconds in a month
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'months' : 'month'} ago`;
+                }
+                interval = secondsSince / 86400; // seconds in a day
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'days' : 'day'} ago`;
+                }
+                interval = secondsSince / 3600; // seconds in an hour
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'hours' : 'hour'} ago`;
+                }
+                interval = secondsSince / 60; // seconds in a minute :)
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'minutes' : 'minute'} ago`;
+                }
+                if (secondsSince > 10) {
+                    const x = Math.floor(secondsSince);
+                    return `${x} ${x > 1 ? 'seconds' : 'second'} ago`;
+                }
+                return 'Now';
+            }
+            else {
+                // in the future
+                var secondsSince = Math.floor((thenDate.getTime() - nowDate.getTime()) / 1000);
+                var interval = secondsSince / 31536000; // seconds in a year
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'years' : 'year'} from now`;
+                }
+                interval = secondsSince / 2592000; // seconds in a month
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'months' : 'month'} from now`;
+                }
+                interval = secondsSince / 86400; // seconds in a day
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'days' : 'day'} from now`;
+                }
+                interval = secondsSince / 3600; // seconds in an hour
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'hours' : 'hour'} from now`;
+                }
+                interval = secondsSince / 60; // seconds in a minute :)
+                if (interval > 1) {
+                    const x = Math.floor(interval);
+                    return `${x} ${x > 1 ? 'minutes' : 'minute'} from now`;
+                }
+                if (secondsSince > 10) {
+                    const x = Math.floor(secondsSince);
+                    return `${x} ${x > 1 ? 'seconds' : 'second'} from now`;
+                }
+                return 'Now';
+            }
+        }
+        return String(nr);
+    }
+    else {
+        return nr;
+    }
+};
+//# sourceMappingURL=timestamp.js.map

package/dist/error.d.ts

@@ -0,0 +1,19 @@
+export declare enum ParseError {
+    'incorrectFieldType' = 0,
+    'incorrectNodeType' = 1,
+    'exceedsMaximum' = 2,
+    'subceedsMinimum' = 3,
+    'fieldDoesNotExist' = 4,
+    'incorrectFormat' = 5,
+    'referenceIsIncorrectType' = 6,
+    'valueAndDefault' = 7,
+    'defaultNotSupported' = 8,
+    'multipleOperationsNotAllowed' = 9,
+    'requiredFieldNotDefined' = 10,
+    'languageNotSupported' = 11,
+    'invalidJSON' = 12,
+    'noLanguageFound' = 13,
+    'cannotDeleteNodeFromModify' = 14,
+    'nestedModifyObjectNotAllowed' = 15,
+    'infinityNotSupported' = 16
+}

package/dist/error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+var ParseError;
+(function (ParseError) {
+    ParseError[ParseError["incorrectFieldType"] = 0] = "incorrectFieldType";
+    ParseError[ParseError["incorrectNodeType"] = 1] = "incorrectNodeType";
+    ParseError[ParseError["exceedsMaximum"] = 2] = "exceedsMaximum";
+    ParseError[ParseError["subceedsMinimum"] = 3] = "subceedsMinimum";
+    ParseError[ParseError["fieldDoesNotExist"] = 4] = "fieldDoesNotExist";
+    ParseError[ParseError["incorrectFormat"] = 5] = "incorrectFormat";
+    ParseError[ParseError["referenceIsIncorrectType"] = 6] = "referenceIsIncorrectType";
+    ParseError[ParseError["valueAndDefault"] = 7] = "valueAndDefault";
+    ParseError[ParseError["defaultNotSupported"] = 8] = "defaultNotSupported";
+    ParseError[ParseError["multipleOperationsNotAllowed"] = 9] = "multipleOperationsNotAllowed";
+    ParseError[ParseError["requiredFieldNotDefined"] = 10] = "requiredFieldNotDefined";
+    ParseError[ParseError["languageNotSupported"] = 11] = "languageNotSupported";
+    ParseError[ParseError["invalidJSON"] = 12] = "invalidJSON";
+    ParseError[ParseError["noLanguageFound"] = 13] = "noLanguageFound";
+    ParseError[ParseError["cannotDeleteNodeFromModify"] = 14] = "cannotDeleteNodeFromModify";
+    ParseError[ParseError["nestedModifyObjectNotAllowed"] = 15] = "nestedModifyObjectNotAllowed";
+    ParseError[ParseError["infinityNotSupported"] = 16] = "infinityNotSupported";
+})(ParseError || (exports.ParseError = ParseError = {}));
+//# sourceMappingURL=error.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './validateSchema';
+export * from './walker';
+export * from './set';
+export * from './display';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./validateSchema"), exports);
+__exportStar(require("./walker"), exports);
+__exportStar(require("./set"), exports);
+__exportStar(require("./display"), exports);
+//# sourceMappingURL=index.js.map

package/dist/languages.d.ts

@@ -0,0 +1,187 @@
+export declare const languages: {
+    ab: string;
+    aa: string;
+    af: string;
+    ak: string;
+    sq: string;
+    am: string;
+    ar: string;
+    an: string;
+    hy: string;
+    as: string;
+    av: string;
+    ae: string;
+    ay: string;
+    az: string;
+    bm: string;
+    ba: string;
+    eu: string;
+    be: string;
+    bn: string;
+    bh: string;
+    bi: string;
+    bs: string;
+    br: string;
+    bg: string;
+    my: string;
+    ca: string;
+    km: string;
+    ch: string;
+    ce: string;
+    ny: string;
+    zh: string;
+    cu: string;
+    cv: string;
+    kw: string;
+    co: string;
+    cr: string;
+    hr: string;
+    cs: string;
+    da: string;
+    dv: string;
+    nl: string;
+    dz: string;
+    en: string;
+    eo: string;
+    et: string;
+    ee: string;
+    fo: string;
+    fj: string;
+    fi: string;
+    fr: string;
+    ff: string;
+    gd: string;
+    gl: string;
+    lg: string;
+    ka: string;
+    de: string;
+    ki: string;
+    el: string;
+    kl: string;
+    gn: string;
+    gu: string;
+    ht: string;
+    ha: string;
+    he: string;
+    hz: string;
+    hi: string;
+    ho: string;
+    hu: string;
+    is: string;
+    io: string;
+    ig: string;
+    id: string;
+    ia: string;
+    ie: string;
+    iu: string;
+    ik: string;
+    ga: string;
+    it: string;
+    ja: string;
+    jv: string;
+    kn: string;
+    kr: string;
+    ks: string;
+    kk: string;
+    rw: string;
+    kv: string;
+    kg: string;
+    ko: string;
+    kj: string;
+    ku: string;
+    ky: string;
+    lo: string;
+    la: string;
+    lv: string;
+    lb: string;
+    li: string;
+    ln: string;
+    lt: string;
+    lu: string;
+    mk: string;
+    mg: string;
+    ms: string;
+    ml: string;
+    mt: string;
+    gv: string;
+    mi: string;
+    mr: string;
+    mh: string;
+    ro: string;
+    mn: string;
+    na: string;
+    nv: string;
+    nd: string;
+    ng: string;
+    ne: string;
+    se: string;
+    no: string;
+    nb: string;
+    nn: string;
+    ii: string;
+    oc: string;
+    oj: string;
+    or: string;
+    om: string;
+    os: string;
+    pi: string;
+    pa: string;
+    ps: string;
+    fa: string;
+    pl: string;
+    pt: string;
+    qu: string;
+    rm: string;
+    rn: string;
+    ru: string;
+    sm: string;
+    sg: string;
+    sa: string;
+    sc: string;
+    sr: string;
+    sn: string;
+    sd: string;
+    si: string;
+    sk: string;
+    sl: string;
+    so: string;
+    st: string;
+    nr: string;
+    es: string;
+    su: string;
+    sw: string;
+    ss: string;
+    sv: string;
+    tl: string;
+    ty: string;
+    tg: string;
+    ta: string;
+    tt: string;
+    te: string;
+    th: string;
+    bo: string;
+    ti: string;
+    to: string;
+    ts: string;
+    tn: string;
+    tr: string;
+    tk: string;
+    tw: string;
+    ug: string;
+    uk: string;
+    ur: string;
+    uz: string;
+    ve: string;
+    vi: string;
+    vo: string;
+    wa: string;
+    cy: string;
+    fy: string;
+    wo: string;
+    xh: string;
+    yi: string;
+    yo: string;
+    za: string;
+    zu: string;
+};
+export type Language = keyof typeof languages;