@based/schema 2.2.10 → 2.2.12

package/dist/{display → src/display}/index.d.ts

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

package/dist/src/display/index.js

@@ -0,0 +1,16 @@
+import timestampDisplay from './timestamp.js';
+import numberDisplay from './number.js';
+import stringDisplay from './string.js';
+export const display = (value, field) => {
+    if (field.type === 'timestamp' && typeof value === 'number') {
+        return timestampDisplay(value, field.display);
+    }
+    if (field.type === 'number' && typeof value === 'number') {
+        return numberDisplay(value, field.display);
+    }
+    if (field.type === 'string' && typeof value === 'string') {
+        return stringDisplay(value, field.display);
+    }
+    return value;
+};
+//# sourceMappingURL=index.js.map

package/dist/{display → src/display}/number.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const parseNumber = (nr, format) => {
     if (!format) {
         return nr;
@@ -85,5 +83,5 @@ const parseNumber = (nr, format) => {
         return nr;
     }
 };
-exports.default = parseNumber;
+export default parseNumber;
 //# sourceMappingURL=number.js.map

package/dist/{display → src/display}/string.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const parseString = (value, format) => {
     if (!format) {
         return value;
@@ -19,5 +17,5 @@ const parseString = (value, format) => {
     }
     return value;
 };
-exports.default = parseString;
+export default parseString;
 //# sourceMappingURL=string.js.map

package/dist/{display → src/display}/timestamp.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const addZero = (d) => {
     const s = d + '';
     if (s.length === 1) {
@@ -7,7 +5,7 @@ const addZero = (d) => {
     }
     return s;
 };
-exports.default = (nr, format) => {
+export default (nr, format) => {
     if (!format) {
         return nr;
     }

package/dist/{error.js → src/error.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseError = void 0;
-var ParseError;
+export var ParseError;
 (function (ParseError) {
     ParseError[ParseError["incorrectFieldType"] = 0] = "incorrectFieldType";
     ParseError[ParseError["incorrectNodeType"] = 1] = "incorrectNodeType";
@@ -20,5 +17,5 @@ var ParseError;
     ParseError[ParseError["cannotDeleteNodeFromModify"] = 14] = "cannotDeleteNodeFromModify";
     ParseError[ParseError["nestedModifyObjectNotAllowed"] = 15] = "nestedModifyObjectNotAllowed";
     ParseError[ParseError["infinityNotSupported"] = 16] = "infinityNotSupported";
-})(ParseError || (exports.ParseError = ParseError = {}));
+})(ParseError || (ParseError = {}));
 //# sourceMappingURL=error.js.map

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './validateSchema.js';
+export * from './walker/index.js';
+export * from './set/index.js';
+export * from './display/index.js';
+//# sourceMappingURL=index.js.map

package/dist/{languages.js → src/languages.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.languages = void 0;
-exports.languages = {
+export const languages = {
     ab: 'Abkhazian',
     aa: 'Afar',
     af: 'Afrikaans',

package/dist/src/set/fields/array.d.ts

@@ -0,0 +1,2 @@
+import { FieldParser } from '../../walker/index.js';
+export declare const array: FieldParser<'array'>;

package/dist/{set → src/set}/fields/array.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.array = void 0;
-const utils_1 = require("@saulx/utils");
-const error_1 = require("../../error");
+import { setByPath } from '@saulx/utils';
+import { ParseError } from '../../error.js';
 const collectOperation = (fromArgs, collected, value, makeNegative) => {
     fromArgs.collect(value);
     if (collected.length) {
@@ -34,7 +31,7 @@ const parseArray = async (args, value, idx = 0) => {
                 const p = nArgs.path.slice(args.path.length);
                 // @ts-ignore
                 p[0] = p[0] - idx;
-                (0, utils_1.setByPath)(arr, p, nArgs.value);
+                setByPath(arr, p, nArgs.value);
                 if (collectNested) {
                     collected.push(nArgs);
                 }
@@ -47,7 +44,7 @@ const parseArray = async (args, value, idx = 0) => {
 const operations = {
     $insert: async (args, value) => {
         if (typeof value.$insert.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
+            args.error(ParseError.incorrectFormat);
             return;
         }
         const { collected, arr } = await parseArray(args, value.$insert.$value, value.$insert.$idx);
@@ -66,7 +63,7 @@ const operations = {
     },
     $remove: async (args, value) => {
         if (typeof value.$remove.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
+            args.error(ParseError.incorrectFormat);
             return;
         }
         args.collect(value);
@@ -74,7 +71,7 @@ const operations = {
     $assign: async (args, value) => {
         if (typeof value.$assign !== 'object' ||
             typeof value.$assign.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
+            args.error(ParseError.incorrectFormat);
             return;
         }
         await args.parse({
@@ -84,10 +81,10 @@ const operations = {
         });
     },
 };
-const array = async (args) => {
+export const array = async (args) => {
     args.stop();
     if (typeof args.value !== 'object') {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     let value = '$value' in args.value ? args.value.$value : args.value;
@@ -108,16 +105,15 @@ const array = async (args) => {
     for (const key in value) {
         if (operations[key]) {
             if (hasOperation) {
-                args.error(error_1.ParseError.multipleOperationsNotAllowed);
+                args.error(ParseError.multipleOperationsNotAllowed);
                 return;
             }
             await operations[key](args, value);
             hasOperation = true;
         }
         else {
-            args.error(error_1.ParseError.fieldDoesNotExist);
+            args.error(ParseError.fieldDoesNotExist);
         }
     }
 };
-exports.array = array;
 //# sourceMappingURL=array.js.map

package/dist/src/set/fields/index.d.ts

@@ -0,0 +1,3 @@
+import { FieldParsers } from '../../walker/index.js';
+import { BasedSetTarget } from '../../types.js';
+export declare const fields: Partial<FieldParsers<BasedSetTarget>>;

package/dist/src/set/fields/index.js

@@ -0,0 +1,71 @@
+import { ParseError } from '../../error.js';
+import { array } from './array.js';
+import { object, record } from './object.js';
+import { number, integer, timestamp } from './number.js';
+import { string, text } from './string.js';
+import { reference, references } from './references.js';
+import { set } from './set.js';
+import { hashObjectIgnoreKeyOrder, hash } from '@saulx/hash';
+import { deepEqual } from '@saulx/utils';
+export const fields = {
+    array,
+    object,
+    record,
+    number,
+    integer,
+    timestamp,
+    string,
+    set,
+    text,
+    reference,
+    references,
+    cardinality: async (args) => {
+        let hashedValue;
+        if (args.value && typeof args.value === 'object') {
+            args.stop();
+            if (args.value.$default !== undefined) {
+                args.error(ParseError.defaultNotSupported);
+                return;
+            }
+            if (args.value.$value !== undefined) {
+                hashedValue = hashObjectIgnoreKeyOrder(args.value.$value).toString(16);
+            }
+            else {
+                hashedValue = hashObjectIgnoreKeyOrder(args.value).toString(16);
+            }
+        }
+        else {
+            hashedValue = hash(args.value).toString(16);
+        }
+        args.collect(hashedValue);
+    },
+    boolean: async (args) => {
+        if (typeof args.value !== 'boolean') {
+            args.error(ParseError.incorrectFormat);
+            return;
+        }
+        args.collect();
+    },
+    json: async (args) => {
+        args.stop();
+        try {
+            const parsedValue = JSON.stringify(args.value);
+            args.collect(parsedValue);
+        }
+        catch (err) {
+            args.error(ParseError.invalidJSON);
+        }
+    },
+    enum: async (args) => {
+        // args.stop()
+        const enumValues = args.fieldSchema.enum;
+        for (let i = 0; i < enumValues.length; i++) {
+            if (deepEqual(enumValues[i], args.value)) {
+                args.collect(i);
+                return;
+            }
+        }
+        args.error(ParseError.incorrectFormat);
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/{set → src/set}/fields/number.d.ts

@@ -1,4 +1,4 @@
-import { FieldParser } from '../../walker';
+import { FieldParser } from '../../walker/index.js';
 export declare const number: FieldParser<'number'>;
 export declare const integer: FieldParser<'integer'>;
 export declare const timestamp: FieldParser<'timestamp'>;

package/dist/{set → src/set}/fields/number.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timestamp = exports.integer = exports.number = void 0;
-const error_1 = require("../../error");
+import { ParseError } from '../../error.js';
 const validateNumber = (args, value, ignoreMinMax) => {
     const { fieldSchema } = args;
     if (typeof value !== 'number') {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     if (isNaN(value)) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     if (value === Infinity || value === -Infinity) {
-        args.error(error_1.ParseError.infinityNotSupported);
+        args.error(ParseError.infinityNotSupported);
         return false;
     }
     if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     if (fieldSchema.multipleOf &&
         value / fieldSchema.multipleOf -
             Math.floor(value / fieldSchema.multipleOf) !==
             0) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     if (ignoreMinMax) {
@@ -34,24 +31,24 @@ const validateNumber = (args, value, ignoreMinMax) => {
     if (fieldSchema.maximum) {
         if (fieldSchema.exclusiveMaximum) {
             if (value >= fieldSchema.maximum) {
-                args.error(error_1.ParseError.exceedsMaximum);
+                args.error(ParseError.exceedsMaximum);
                 return false;
             }
         }
         else if (value > fieldSchema.maximum) {
-            args.error(error_1.ParseError.exceedsMaximum);
+            args.error(ParseError.exceedsMaximum);
             return false;
         }
     }
     if (fieldSchema.minimum) {
         if (fieldSchema.exclusiveMinimum) {
             if (value <= fieldSchema.minimum) {
-                args.error(error_1.ParseError.subceedsMinimum);
+                args.error(ParseError.subceedsMinimum);
                 return false;
             }
         }
         else if (value < fieldSchema.minimum) {
-            args.error(error_1.ParseError.subceedsMinimum);
+            args.error(ParseError.subceedsMinimum);
             return false;
         }
     }
@@ -85,27 +82,25 @@ const validate = (args, value) => {
             }
         }
         else {
-            args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
+            args.create({ key }).error(ParseError.fieldDoesNotExist);
             return false;
         }
     }
     return true;
 };
-const number = async (args) => {
+export const number = async (args) => {
     if (!validate(args, args.value)) {
         return;
     }
     args.collect();
 };
-exports.number = number;
-const integer = async (args) => {
+export const integer = async (args) => {
     if (!validate(args, args.value)) {
         return;
     }
     args.collect();
 };
-exports.integer = integer;
-const timestamp = async (args) => {
+export const timestamp = async (args) => {
     if (typeof args.value === 'string') {
         if (args.value === 'now') {
             // TODO: + 1s + 10s etc
@@ -115,7 +110,7 @@ const timestamp = async (args) => {
             const d = new Date(args.value);
             args.value = d.valueOf();
             if (isNaN(args.value)) {
-                args.error(error_1.ParseError.incorrectFormat);
+                args.error(ParseError.incorrectFormat);
                 return;
             }
         }
@@ -125,5 +120,4 @@ const timestamp = async (args) => {
     }
     args.collect();
 };
-exports.timestamp = timestamp;
 //# sourceMappingURL=number.js.map

package/dist/{set → src/set}/fields/object.d.ts

@@ -1,3 +1,3 @@
-import { FieldParser } from '../../walker';
+import { FieldParser } from '../../walker/index.js';
 export declare const object: FieldParser<'object'>;
 export declare const record: FieldParser<'record'>;

package/dist/src/set/fields/object.js

@@ -0,0 +1,28 @@
+import { ParseError } from '../../error.js';
+export const object = async (args) => {
+    if (typeof args.value !== 'object' || args.value === null) {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    const isArray = Array.isArray(args.value);
+    if (isArray) {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    args.collect();
+    return args;
+};
+export const record = async (args) => {
+    if (typeof args.value !== 'object' || args.value === null) {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    const isArray = Array.isArray(args.value);
+    if (isArray) {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    args.collect();
+    return args;
+};
+//# sourceMappingURL=object.js.map

package/dist/{set → src/set}/fields/references.d.ts

@@ -1,3 +1,3 @@
-import { FieldParser } from '../../walker';
+import { FieldParser } from '../../walker/index.js';
 export declare const reference: FieldParser<'reference'>;
 export declare const references: FieldParser<'references'>;

package/dist/{set → src/set}/fields/references.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.references = exports.reference = void 0;
-const error_1 = require("../../error");
-const isValidId_1 = require("../isValidId");
+import { ParseError } from '../../error.js';
+import { isValidId } from '../isValidId.js';
 async function parseOperator(args, key) {
     if (Array.isArray(args.value[key])) {
         const n = args.create({
@@ -21,7 +18,7 @@ async function parseOperator(args, key) {
         key,
         skipCollection: true,
     });
-    await (0, exports.reference)(n);
+    await reference(n);
     return [n.value];
 }
 const typeIsAllowed = (args, type) => {
@@ -58,13 +55,13 @@ const typeIsAllowed = (args, type) => {
     }
     return true;
 };
-const reference = async (args) => {
+export const reference = async (args) => {
     // TODO: setting an object here , handling $alias (both async hooks)
     // Block if path contains $remove (maybe not for $alias)
     if (typeof args.value === 'object') {
         if (args.root._opts.asyncOperationHandler) {
             if (args.value.type && !typeIsAllowed(args, args.value.type)) {
-                args.error(error_1.ParseError.referenceIsIncorrectType);
+                args.error(ParseError.referenceIsIncorrectType);
                 return;
             }
             if (!args.target.errors.length) {
@@ -72,12 +69,12 @@ const reference = async (args) => {
             }
         }
         else {
-            args.error(error_1.ParseError.nestedModifyObjectNotAllowed);
+            args.error(ParseError.nestedModifyObjectNotAllowed);
             return;
         }
     }
-    if (!(0, isValidId_1.isValidId)(args.schema, args.value)) {
-        args.error(error_1.ParseError.incorrectFormat);
+    if (!isValidId(args.schema, args.value)) {
+        args.error(ParseError.incorrectFormat);
         return;
     }
     const prefix = args.value.slice(0, 2);
@@ -86,14 +83,13 @@ const reference = async (args) => {
         args.collect();
     }
     else {
-        args.error(error_1.ParseError.referenceIsIncorrectType);
+        args.error(ParseError.referenceIsIncorrectType);
     }
 };
-exports.reference = reference;
-const references = async (args) => {
+export const references = async (args) => {
     const { value } = args;
     if (typeof value !== 'object' || value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     args.stop();
@@ -104,7 +100,7 @@ const references = async (args) => {
                 key,
                 skipCollection: true,
             });
-            await (0, exports.reference)(n);
+            await reference(n);
             return n.value;
         }));
         args.value = { $value: parseValues };
@@ -118,11 +114,10 @@ const references = async (args) => {
                 args.value.$remove = await parseOperator(args, key);
             }
             else {
-                args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
+                args.create({ key }).error(ParseError.fieldDoesNotExist);
             }
         }
     }
     args.collect();
 };
-exports.references = references;
 //# sourceMappingURL=references.js.map

package/dist/src/set/fields/set.d.ts

@@ -0,0 +1,2 @@
+import { FieldParser } from '../../walker/index.js';
+export declare const set: FieldParser<'set'>;

package/dist/{set → src/set}/fields/set.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.set = void 0;
-const error_1 = require("../../error");
+import { ParseError } from '../../error.js';
 async function parseOperator(args, key) {
     if (Array.isArray(args.value[key])) {
         const n = args.create({
@@ -24,9 +21,9 @@ async function parseOperator(args, key) {
     await n.parse();
     return [n.value];
 }
-const set = async (args) => {
+export const set = async (args) => {
     if (typeof args.value !== 'object' || args.value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     args.stop();
@@ -53,11 +50,10 @@ const set = async (args) => {
                 args.value.$remove = await parseOperator(args, key);
             }
             else {
-                args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
+                args.create({ key }).error(ParseError.fieldDoesNotExist);
             }
         }
     }
     args.collect();
 };
-exports.set = set;
 //# sourceMappingURL=set.js.map

package/dist/{set → src/set}/fields/string.d.ts

@@ -1,3 +1,3 @@
-import { FieldParser } from '../../walker';
+import { FieldParser } from '../../walker/index.js';
 export declare const string: FieldParser<'string'>;
 export declare const text: FieldParser<'text'>;