@based/schema 4.1.1 → 5.0.0-alpha.0

package/dist/test/display.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/display.js

@@ -1,103 +0,0 @@
-import test from 'ava';
-import { display } from '../src/index.js';
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                dateHuman: { type: 'timestamp', display: 'human' },
-                dateTime: { type: 'timestamp', display: 'date-time' },
-                dateTimeText: { type: 'timestamp', display: 'date-time-text' },
-                time: { type: 'timestamp', display: 'time' },
-                timePrecise: { type: 'timestamp', display: 'time-precise' },
-                capitalize: {
-                    type: 'string',
-                    display: 'capitalize',
-                    format: 'lowercase',
-                },
-                upperCase: { type: 'string', display: 'uppercase' },
-                lowerCase: { type: 'string', display: 'lowercase' },
-                euros: { type: 'number', display: 'euro' },
-                dollars: { type: 'number', display: 'dollar' },
-                pounds: { type: 'number', display: 'pound' },
-                bytes: { type: 'number', display: 'bytes' },
-                humanNumber: { type: 'number', display: 'human' },
-                ratio: { type: 'number', display: 'ratio' },
-                short: { type: 'number', display: 'short' },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-test('date display', async (t) => {
-    const now = 1701695869765;
-    const parsed = [
-        display('bla', schema.types.thing.fields.capitalize),
-        display('b', schema.types.thing.fields.capitalize),
-        display(undefined, schema.types.thing.fields.capitalize),
-        display('', schema.types.thing.fields.capitalize),
-        display('bla', schema.types.thing.fields.upperCase),
-        display('BLA', schema.types.thing.fields.lowerCase),
-        display(100000, schema.types.thing.fields.euros),
-        display(100000, schema.types.thing.fields.dollars),
-        display(10.21, schema.types.thing.fields.euros),
-        display(10.2312234342, schema.types.thing.fields.dollars),
-        display(1001.21212, schema.types.thing.fields.euros),
-        display(1001.21212, schema.types.thing.fields.dollars),
-        display(10000.21212, schema.types.thing.fields.euros),
-        display(10000.21212, schema.types.thing.fields.dollars),
-        display(100e6, schema.types.thing.fields.euros),
-        display(100e6, schema.types.thing.fields.dollars),
-        display(100e6, schema.types.thing.fields.bytes),
-        display(100e9, schema.types.thing.fields.bytes),
-        display(100e9, schema.types.thing.fields.short),
-    ];
-    t.deepEqual(parsed, [
-        'Bla',
-        'B',
-        undefined,
-        '',
-        'BLA',
-        'bla',
-        '€100k',
-        '$100k',
-        '€10,21',
-        '$10.23',
-        '€1001,21',
-        '$1001.21',
-        '€10k',
-        '$10k',
-        '€100m',
-        '$100m',
-        '95.37 mb',
-        '93.13 gb',
-        '100b',
-    ]);
-    const dates = [
-        display(now + 20e3, schema.types.thing.fields.dateTimeText),
-        display(now + 20e3, schema.types.thing.fields.timePrecise),
-        display(now + 20e3, schema.types.thing.fields.dateTime),
-        display(now + 20e3, {
-            type: 'timestamp',
-            display: 'date-time-text',
-        }),
-    ];
-    for (const d of dates) {
-        if (!d) {
-            t.fail('date is not parsed');
-        }
-    }
-    t.regex(String(display(now + 20e3, schema.types.thing.fields.dateTimeText)), /^December 4, 2023, *./);
-    t.regex(String(display(now + 20e3, schema.types.thing.fields.timePrecise)), /^[0-9]{2}:18:09$/);
-    t.regex(String(display(now + 20e3, schema.types.thing.fields.dateTime)), /^[0-9]{2}:18 4\/12\/2023$/);
-    t.regex(String(display(now + 20e3, schema.types.thing.fields.time)), /^[0-9]{2}:18$/);
-});
-//# sourceMappingURL=display.js.map

package/dist/test/json.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/json.js

@@ -1,40 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { errorCollect, resultCollect } from './utils/index.js';
-const schema = {
-    types: {
-        aType: {
-            prefix: 'at',
-            fields: {
-                json: {
-                    type: 'json',
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        at: 'aType',
-    },
-};
-test('json field with keys in it', async (t) => {
-    const json = {
-        fieldA: 'record2FieldA',
-        $id: '$id_inside_json',
-        $alias: '$alias_inside_json',
-    };
-    const res = await setWalker(schema, {
-        // type: 'aType',
-        $id: 'at1',
-        json,
-    });
-    t.assert(!errorCollect(res).length);
-    t.deepEqual(resultCollect(res), [
-        { path: ['json'], value: JSON.stringify(json) },
-    ]);
-});
-//# sourceMappingURL=json.js.map

package/dist/test/number.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/number.js

@@ -1,374 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { resultCollect, errorCollect } from './utils/index.js';
-const schema = {
-    types: {
-        bla: {
-            prefix: 'bl',
-            fields: {
-                number: {
-                    type: 'number',
-                    maximum: 6,
-                    minimum: 3,
-                },
-                infiniteNum: {
-                    type: 'number',
-                },
-                infiniteInt: {
-                    type: 'integer',
-                },
-                exclusiveminmax: {
-                    type: 'number',
-                    minimum: 3,
-                    exclusiveMinimum: true,
-                    maximum: 6,
-                    exclusiveMaximum: true,
-                },
-                integer: {
-                    type: 'integer',
-                },
-                multipleOf: {
-                    type: 'integer',
-                    multipleOf: 3,
-                },
-                set: {
-                    type: 'set',
-                    items: { type: 'number', minimum: 3, maximum: 6 },
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-    },
-};
-//todo need help typing this maybe
-test('min-max', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: 1,
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        number: 10,
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: 3,
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        number: 6,
-    });
-    t.true(errorCollect(e1, e2).length > 0);
-    t.deepEqual(resultCollect(res1, res2), [
-        { path: ['number'], value: 3 },
-        { path: ['number'], value: 6 },
-    ]);
-});
-test('min-max exclusive', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: 3,
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: 6,
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: 4,
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: 5,
-    });
-    t.assert(errorCollect(e1, e2).length > 0);
-    t.deepEqual(resultCollect(res1, res2), [
-        { path: ['exclusiveminmax'], value: 4 },
-        { path: ['exclusiveminmax'], value: 5 },
-    ]);
-});
-test('isInteger', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: 6.5,
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: 5,
-    });
-    t.assert(errorCollect(e1).length > 0);
-    t.deepEqual(resultCollect(res1), [{ path: ['integer'], value: 5 }]);
-});
-test('isMultiple', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: 7,
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: 9,
-    });
-    t.assert(errorCollect(e1).length > 0);
-    t.deepEqual(resultCollect(res1), [{ path: ['multipleOf'], value: 9 }]);
-});
-//TODO fix
-test('numbers in a set', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        set: [9, 4, 5, 2],
-    });
-    const res1 = await setWalker(schema, { $id: 'bl1', set: [3, 3, 3, 3] });
-    t.assert(errorCollect(e1).length > 0);
-    t.deepEqual(resultCollect(res1), [
-        { path: ['set'], value: { $value: [3, 3, 3, 3] } },
-    ]);
-});
-//TODO fix
-test('value', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $value: 7 },
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $value: 3 },
-    });
-    const e3 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { value: 3.5 },
-    });
-    const e4 = await setWalker(schema, {
-        $id: 'bl1',
-        set: { $value: [1, 3, 3, 4] },
-    });
-    const e5 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $value: 2 },
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $value: 4 },
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $value: 4 },
-    });
-    const res3 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $value: 4 },
-    });
-    const res4 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $value: 6 },
-    });
-    await setWalker(schema, {
-        $id: 'bl1',
-        set: { $value: [3, 3, 3, 4] },
-    });
-    t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0);
-    t.deepEqual(resultCollect(res1, res2, res3, res4), [
-        { path: ['number'], value: 4 },
-        { path: ['integer'], value: 4 },
-        { path: ['exclusiveminmax'], value: 4 },
-        { path: ['multipleOf'], value: 6 },
-    ]);
-});
-test('default', async (t) => {
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $default: 7 },
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $default: 3 },
-    });
-    const e3 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { default: 3.5 },
-    });
-    const e4 = await setWalker(schema, {
-        $id: 'bl1',
-        set: { $default: [1, 3, 3, 4] },
-    });
-    const e5 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $default: 2 },
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $default: 4 },
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $default: 4 },
-    });
-    const res3 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $default: 4 },
-    });
-    const res4 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $default: 6 },
-    });
-    const res5 = await setWalker(schema, {
-        $id: 'bl1',
-        set: { $default: [3, 3, 3, 4] },
-    });
-    t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0);
-    t.deepEqual(resultCollect(res1, res2, res3, res4, res5), [
-        { path: ['number'], value: { $default: 4 } },
-        { path: ['integer'], value: { $default: 4 } },
-        { path: ['exclusiveminmax'], value: { $default: 4 } },
-        { path: ['multipleOf'], value: { $default: 6 } },
-        { path: ['set'], value: { $default: { $value: [3, 3, 3, 4] } } },
-    ]);
-});
-test('decrement', async (t) => {
-    //maxmin
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $decrement: 2 },
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $decrement: 7 },
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $decrement: 3 },
-    });
-    //exclusiveminmax
-    const e3 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $decrement: 3 },
-    });
-    const e4 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $decrement: 6 },
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $decrement: 4 },
-    });
-    //integer
-    const e5 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $decrement: 3.5 },
-    });
-    const res3 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $decrement: 3 },
-    });
-    //multiple of
-    const e6 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $decrement: 7 },
-    });
-    const res4 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $decrement: 9 },
-    });
-    t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0);
-    t.deepEqual(resultCollect(res1, res2, res3, res4), [
-        { path: ['number'], value: { $decrement: 3 } },
-        { path: ['exclusiveminmax'], value: { $decrement: 4 } },
-        { path: ['integer'], value: { $decrement: 3 } },
-        { path: ['multipleOf'], value: { $decrement: 9 } },
-    ]);
-});
-test('increment', async (t) => {
-    //maxmin
-    const e1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $increment: 2 },
-    });
-    const e2 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $increment: 7 },
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        number: { $increment: 3 },
-    });
-    //exclusiveminmax
-    const e3 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $increment: 3 },
-    });
-    const e4 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $increment: 6 },
-    });
-    const res2 = await setWalker(schema, {
-        $id: 'bl1',
-        exclusiveminmax: { $increment: 4 },
-    });
-    //integer
-    const e5 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $increment: 3.5 },
-    });
-    const res3 = await setWalker(schema, {
-        $id: 'bl1',
-        integer: { $increment: 3 },
-    });
-    //multiple of
-    const e6 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $increment: 7 },
-    });
-    const res4 = await setWalker(schema, {
-        $id: 'bl1',
-        multipleOf: { $increment: 9 },
-    });
-    t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0);
-    t.deepEqual(resultCollect(res1, res2, res3, res4), [
-        { path: ['number'], value: { $increment: 3 } },
-        { path: ['exclusiveminmax'], value: { $increment: 4 } },
-        { path: ['integer'], value: { $increment: 3 } },
-        { path: ['multipleOf'], value: { $increment: 9 } },
-    ]);
-});
-test('NaN', async (t) => {
-    const r = await setWalker(schema, {
-        $id: 'bl120',
-        integer: NaN,
-    });
-    t.is(r.errors.length, 1);
-});
-test('Infinity (integer)', async (t) => {
-    const r = await setWalker(schema, {
-        $id: 'bl120',
-        integer: Infinity,
-    });
-    t.is(r.errors.length, 1);
-});
-test('Infinity (number)', async (t) => {
-    const r = await setWalker(schema, {
-        $id: 'bl120',
-        infiniteNum: Infinity,
-    });
-    t.is(r.errors.length, 1);
-});
-test('number -infinity', async (t) => {
-    const r = await setWalker(schema, {
-        $id: 'bl120',
-        infiniteNum: -Infinity,
-    });
-    t.is(r.errors.length, 1);
-});
-test('number with max infinity', async (t) => {
-    const r = await setWalker(schema, {
-        $id: 'bl120',
-        number: Infinity,
-    });
-    t.is(r.errors.length, 1);
-});
-//# sourceMappingURL=number.js.map

package/dist/test/reference.d.ts

@@ -1 +0,0 @@
-export {};