@based/schema 2.5.3 → 2.7.0

package/dist/src/compat/oldToNew.js

@@ -0,0 +1,210 @@
+const DEFAULT_FIELDS = {
+// id: { type: 'string' },
+// createdAt: { type: 'timestamp' },
+// updatedAt: { type: 'timestamp' },
+// type: { type: 'string' },
+// parents: { type: 'references' },
+// children: { type: 'references' },
+// ancestors: { type: 'references' },
+// descendants: { type: 'references' },
+// aliases: {
+//   type: 'set',
+//   items: { type: 'string' },
+// },
+};
+const metaParser = (obj) => {
+    const metaObj = obj?.meta;
+    const tmp = {};
+    for (const i in metaObj) {
+        if (i === 'name') {
+            tmp.title = metaObj[i];
+        }
+        else if (i === 'validation' ||
+            i === 'progress' ||
+            i === 'format' ||
+            i === 'ui') {
+            if (metaObj[i] === 'url') {
+                // tmp.format = 'URL'
+            }
+            if ((metaObj[i] === 'bytes' && obj.type === 'number') ||
+                metaObj.type === 'float') {
+                tmp.display = 'bytes';
+            }
+        }
+        else {
+            tmp[i] = metaObj[i];
+        }
+    }
+    return tmp;
+};
+const migrateField = (oldField) => {
+    switch (oldField.type) {
+        case 'object':
+            return {
+                ...metaParser(oldField),
+                type: 'object',
+                properties: migrateFields(oldField.properties, true),
+            };
+        case 'json':
+            return {
+                ...oldField,
+                ...metaParser(oldField),
+                type: 'json',
+            };
+        case 'array':
+            const values = migrateField(oldField.items);
+            if (!values) {
+                return null;
+            }
+            return {
+                ...metaParser(oldField),
+                type: 'array',
+                values,
+            };
+        case 'set':
+            return {
+                ...metaParser(oldField),
+                type: 'set',
+                items: migrateField(oldField.items),
+            };
+        case 'record':
+            return {
+                ...metaParser(oldField),
+                type: 'record',
+                values: migrateField(oldField.values),
+            };
+        case 'reference':
+        case 'references':
+            return {
+                ...metaParser(oldField),
+                type: oldField.type,
+                ...(oldField.bidirectional
+                    ? { bidirectional: oldField.bidirectional }
+                    : null),
+            };
+        case 'float':
+            return {
+                ...metaParser(oldField),
+                type: 'number',
+            };
+        case 'int':
+            return {
+                ...metaParser(oldField),
+                type: 'integer',
+            };
+        case 'digest':
+            return {
+                ...metaParser(oldField),
+                format: 'strongPassword',
+                type: 'string',
+            };
+        case 'id':
+            return {
+                format: 'basedId',
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'url':
+            return {
+                ...metaParser(oldField),
+                format: 'URL',
+                type: 'string',
+            };
+        case 'email':
+            return {
+                format: 'email',
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'phone':
+            return {
+                ...metaParser(oldField),
+                format: 'mobilePhone',
+                type: 'string',
+            };
+        case 'geo':
+            return {
+                ...metaParser(oldField),
+                format: 'latLong',
+                type: 'string',
+            };
+        case 'type':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'number':
+            return {
+                ...metaParser(oldField),
+                type: 'number',
+            };
+        default:
+            return {
+                ...metaParser(oldField),
+                type: oldField.type,
+            };
+    }
+};
+const migrateFields = (oldFields, recursing = false) => {
+    const result = {};
+    if (oldFields) {
+        for (const key in oldFields) {
+            if (true) {
+                if (!recursing && Object.keys(DEFAULT_FIELDS).includes(key)) {
+                    continue;
+                }
+                const field = migrateField(oldFields[key]);
+                if (!field) {
+                    continue;
+                }
+                result[key] = field;
+            }
+        }
+    }
+    return result;
+};
+const migrateTypes = (oldSchema) => {
+    const result = {
+        types: {},
+    };
+    for (const key in oldSchema.types) {
+        if (oldSchema.types.hasOwnProperty(key)) {
+            const type = oldSchema.types[key];
+            result.types[key] = {
+                ...metaParser(type),
+                prefix: type.prefix,
+                fields: migrateFields(type.fields),
+            };
+        }
+    }
+    return result;
+};
+const convertRoot = (oldSchema) => {
+    const result = {
+        fields: {},
+        ...metaParser(oldSchema.rootType?.meta),
+        ...(oldSchema.rootType?.prefix
+            ? { prefix: oldSchema.rootType.prefix }
+            : null),
+    };
+    for (const i in oldSchema.rootType?.fields) {
+        const field = oldSchema.rootType?.fields[i];
+        result.fields[i] = {
+            ...metaParser(field?.meta),
+            ...migrateField(field),
+        };
+    }
+    return result;
+};
+export const convertOldToNew = (oldSchema) => {
+    const tempSchema = migrateTypes(oldSchema);
+    tempSchema.$defs = {};
+    tempSchema.language = oldSchema.languages[0];
+    tempSchema.prefixToTypeMapping = oldSchema.prefixToTypeMapping;
+    tempSchema.translations = oldSchema.languages.filter((_, i) => i !== 0);
+    tempSchema.root = convertRoot(oldSchema);
+    delete tempSchema.rootType;
+    delete tempSchema.sha;
+    return tempSchema;
+};
+//# sourceMappingURL=oldToNew.js.map

package/dist/src/display/number.d.ts

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

package/dist/src/display/number.js

@@ -1,3 +1,13 @@
+export const basedSchemaNumberFormats = [
+    ,
+    'short',
+    'human',
+    'ratio',
+    'bytes',
+    'euro',
+    'dollar',
+    'pound',
+];
 const parseNumber = (nr, format) => {
     if (!format) {
         return nr;

package/dist/src/display/string.d.ts

@@ -1,3 +1,5 @@
-export type StringFormat = 'lowercase' | 'uppercase' | 'capitalize';
+export declare const basedSchemaDisplayFormats: readonly ["lowercase", "uppercase", "capitalize"];
+export type basedSchemaDisplayFormat = (typeof basedSchemaDisplayFormats)[number];
+export type StringFormat = basedSchemaDisplayFormat;
 declare const parseString: (value?: string, format?: StringFormat) => string;
 export default parseString;

package/dist/src/display/string.js

@@ -1,3 +1,8 @@
+export const basedSchemaDisplayFormats = [
+    'lowercase',
+    'uppercase',
+    'capitalize',
+];
 const parseString = (value, format) => {
     if (!format) {
         return value;

package/dist/src/display/timestamp.d.ts

@@ -1,3 +1,5 @@
-export type DateFormat = 'date' | 'date-time' | 'date-time-text' | 'human' | 'time' | 'time-precise';
+export declare const basedSchemaDateFormats: readonly [any, "date", "date-time", "date-time-text", "human", "time", "time-precise"];
+export type BasedSchemaDateFormat = (typeof basedSchemaDateFormats)[number];
+export type DateFormat = BasedSchemaDateFormat;
 declare const _default: (nr: number | string, format?: DateFormat) => string | number;
 export default _default;

package/dist/src/display/timestamp.js

@@ -1,3 +1,12 @@
+export const basedSchemaDateFormats = [
+    ,
+    'date',
+    'date-time',
+    'date-time-text',
+    'human',
+    'time',
+    'time-precise',
+];
 const addZero = (d) => {
     const s = d + '';
     if (s.length === 1) {

package/dist/src/error.d.ts

@@ -15,5 +15,7 @@ export declare enum ParseError {
     'noLanguageFound' = 13,
     'cannotDeleteNodeFromModify' = 14,
     'nestedModifyObjectNotAllowed' = 15,
-    'infinityNotSupported' = 16
+    'infinityNotSupported' = 16,
+    'invalidSchemaFormat' = 17,
+    'invalidProperty' = 18
 }

package/dist/src/error.js

@@ -17,5 +17,7 @@ export var ParseError;
     ParseError[ParseError["cannotDeleteNodeFromModify"] = 14] = "cannotDeleteNodeFromModify";
     ParseError[ParseError["nestedModifyObjectNotAllowed"] = 15] = "nestedModifyObjectNotAllowed";
     ParseError[ParseError["infinityNotSupported"] = 16] = "infinityNotSupported";
+    ParseError[ParseError["invalidSchemaFormat"] = 17] = "invalidSchemaFormat";
+    ParseError[ParseError["invalidProperty"] = 18] = "invalidProperty";
 })(ParseError || (ParseError = {}));
 //# sourceMappingURL=error.js.map

package/dist/src/index.d.ts

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

package/dist/src/index.js

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

package/dist/src/types.d.ts

@@ -43,23 +43,25 @@ export type BasedSchemaFieldShared = {
     };
     $delete?: boolean;
 };
+export declare const basedSchemaStringFormatValues: readonly ["email", "URL", "MACAddress", "IP", "IPRange", "FQDN", "IBAN", "BIC", "alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "passportNumber", "port", "lowercase", "uppercase", "ascii", "semVer", "surrogatePair", "IMEI", "hexadecimal", "octal", "hexColor", "rgbColor", "HSL", "ISRC", "MD5", "JWT", "UUID", "luhnNumber", "creditCard", "identityCard", "EAN", "ISIN", "ISBN", "ISSN", "mobilePhone", "mobilePhoneLocales", "postalCode", "postalCodeLocales", "ethereumAddress", "currency", "btcAddress", "ISO6391", "ISO8601", "RFC3339", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "base32", "base58", "base64", "dataURI", "magnetURI", "mimeType", "latLong", "slug", "strongPassword", "taxID", "licensePlate", "VAT", "code", "typescript", "javascript", "python", "rust", "css", "html", "json", "markdown", "clike", "basedId"];
 export type BasedSchemaStringShared = {
     minLength?: number;
     maxLength?: number;
     contentMediaEncoding?: string;
     contentMediaType?: BasedSchemaContentMediaType;
     pattern?: BasedSchemaPattern;
-    format?: 'email' | 'URL' | 'MACAddress' | 'IP' | 'IPRange' | 'FQDN' | 'IBAN' | 'BIC' | 'alpha' | 'alphaLocales' | 'alphanumeric' | 'alphanumericLocales' | 'passportNumber' | 'port' | 'lowercase' | 'uppercase' | 'ascii' | 'semVer' | 'surrogatePair' | 'IMEI' | 'hexadecimal' | 'octal' | 'hexColor' | 'rgbColor' | 'HSL' | 'ISRC' | 'MD5' | 'JWT' | 'UUID' | 'luhnNumber' | 'creditCard' | 'identityCard' | 'EAN' | 'ISIN' | 'ISBN' | 'ISSN' | 'mobilePhone' | 'mobilePhoneLocales' | 'postalCode' | 'postalCodeLocales' | 'ethereumAddress' | 'currency' | 'btcAddress' | 'ISO6391' | 'ISO8601' | 'RFC3339' | 'ISO31661Alpha2' | 'ISO31661Alpha3' | 'ISO4217' | 'base32' | 'base58' | 'base64' | 'dataURI' | 'magnetURI' | 'mimeType' | 'latLong' | 'slug' | 'strongPassword' | 'taxID' | 'licensePlate' | 'VAT' | 'code' | 'typescript' | 'javascript' | 'python' | 'rust' | 'css' | 'html' | 'json' | 'markdown' | 'clike' | 'basedId';
+    format?: (typeof basedSchemaStringFormatValues)[number];
     display?: StringFormat;
     multiline?: boolean;
 };
-type NumberDefaults = {
+export type BasedSchemaNumberDefaults = {
     multipleOf?: number;
     minimum?: number;
     maximum?: number;
     exclusiveMaximum?: boolean;
     exclusiveMinimum?: boolean;
 };
+export type NumberDefaults = BasedSchemaNumberDefaults;
 export type BasedNumberDisplay = NumberFormat;
 export type BasedTimestampDisplay = DateFormat;
 export type BasedSchemaFieldString = {
@@ -209,4 +211,3 @@ export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
         typeSchema: BasedSchemaType;
     };
 };
-export {};

package/dist/src/types.js

@@ -21,4 +21,78 @@ export const isCollection = (type) => {
     return type === 'array' || type === 'object' || type === 'record';
 };
 export const languages = Object.keys(allLanguages);
+export const basedSchemaStringFormatValues = [
+    'email',
+    'URL',
+    'MACAddress',
+    'IP',
+    'IPRange',
+    'FQDN',
+    'IBAN',
+    'BIC',
+    'alpha',
+    'alphaLocales',
+    'alphanumeric',
+    'alphanumericLocales',
+    'passportNumber',
+    'port',
+    'lowercase',
+    'uppercase',
+    'ascii',
+    'semVer',
+    'surrogatePair',
+    'IMEI',
+    'hexadecimal',
+    'octal',
+    'hexColor',
+    'rgbColor',
+    'HSL',
+    'ISRC',
+    'MD5',
+    'JWT',
+    'UUID',
+    'luhnNumber',
+    'creditCard',
+    'identityCard',
+    'EAN',
+    'ISIN',
+    'ISBN',
+    'ISSN',
+    'mobilePhone',
+    'mobilePhoneLocales',
+    'postalCode',
+    'postalCodeLocales',
+    'ethereumAddress',
+    'currency',
+    'btcAddress',
+    'ISO6391',
+    'ISO8601',
+    'RFC3339',
+    'ISO31661Alpha2',
+    'ISO31661Alpha3',
+    'ISO4217',
+    'base32',
+    'base58',
+    'base64',
+    'dataURI',
+    'magnetURI',
+    'mimeType',
+    'latLong',
+    'slug',
+    'strongPassword',
+    'taxID',
+    'licensePlate',
+    'VAT',
+    'code',
+    'typescript',
+    'javascript',
+    'python',
+    'rust',
+    'css',
+    'html',
+    'json',
+    'markdown',
+    'clike',
+    'basedId',
+];
 //# sourceMappingURL=types.js.map

package/dist/src/validateSchema/basedSchemaTypeValidator.d.ts

@@ -0,0 +1,3 @@
+import { BasedSchemaType } from '../types.js';
+import { Validator } from './index.js';
+export declare const basedSchemaTypeValidator: Validator<BasedSchemaType>;

package/dist/src/validateSchema/basedSchemaTypeValidator.js

@@ -0,0 +1,45 @@
+import { deepEqual } from '@saulx/utils';
+import { ParseError } from '../error.js';
+import { mustBeBoolean, mustBeString, mustBeStringArray } from './utils.js';
+import { mustBeFields } from './fieldValidators.js';
+export const basedSchemaTypeValidator = {
+    directory: {
+        validator: mustBeString,
+        optional: true,
+    },
+    fields: {
+        validator: mustBeFields,
+    },
+    title: {
+        validator: mustBeString,
+        optional: true,
+    },
+    description: {
+        validator: mustBeString,
+        optional: true,
+    },
+    prefix: {
+        validator: (value, path) => {
+            if (deepEqual(path, ['root', 'prefix'])) {
+                return value === 'ro'
+                    ? []
+                    : [{ code: ParseError.incorrectFormat, path }];
+            }
+            return /^[a-z]{2}$/.test(value)
+                ? []
+                : [{ code: ParseError.incorrectFormat, path }];
+        },
+        optional: true,
+    },
+    examples: { optional: true },
+    required: {
+        validator: mustBeStringArray,
+        optional: true,
+    },
+    $defs: { optional: true },
+    $delete: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+//# sourceMappingURL=basedSchemaTypeValidator.js.map

package/dist/src/validateSchema/fieldValidators.d.ts

@@ -0,0 +1,27 @@
+import { BasedSchema, BasedSchemaFieldAny, BasedSchemaFieldArray, BasedSchemaFieldBoolean, BasedSchemaFieldCardinality, BasedSchemaFieldEnum, BasedSchemaFieldInteger, BasedSchemaFieldJSON, BasedSchemaFieldNumber, BasedSchemaFieldObject, BasedSchemaFieldRecord, BasedSchemaFieldReference, BasedSchemaFieldReferences, BasedSchemaFieldSet, BasedSchemaFieldShared, BasedSchemaFieldString, BasedSchemaFieldText, BasedSchemaFieldTimeStamp, BasedSchemaNumberDefaults, BasedSchemaPartial, BasedSchemaStringShared } from '../types.js';
+import { ValidateSchemaError, Validator } from './index.js';
+type MustBeFieldOptions = {
+    limitTo?: 'primitives' | 'enumerables';
+};
+export declare const mustBeField: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema, options?: MustBeFieldOptions) => ValidateSchemaError[];
+export declare const mustBeFields: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
+export declare const basedSchemaFieldSharedValidator: Validator<BasedSchemaFieldShared>;
+export declare const basedSchemaStringSharedValidator: Validator<BasedSchemaStringShared>;
+export declare const basedSchemaStringValidator: Validator<BasedSchemaFieldString>;
+export declare const basedSchemaFieldEnumValidator: Validator<BasedSchemaFieldEnum>;
+export declare const basedSchemaFieldCardinalityValidator: Validator<BasedSchemaFieldCardinality>;
+export declare const basedSchemaNumberDefaultsValidator: Validator<BasedSchemaNumberDefaults>;
+export declare const basedSchemaFieldNumberValidator: Validator<BasedSchemaFieldNumber>;
+export declare const basedSchemaFieldIntegerValidator: Validator<BasedSchemaFieldInteger>;
+export declare const basedSchemaFieldTimeStampValidator: Validator<BasedSchemaFieldTimeStamp>;
+export declare const basedSchemaFieldBooleanValidator: Validator<BasedSchemaFieldBoolean>;
+export declare const basedSchemaFieldJSONValidator: Validator<BasedSchemaFieldJSON>;
+export declare const basedSchemaFieldAnyValidator: Validator<BasedSchemaFieldAny>;
+export declare const basedSchemaFieldTextValidator: Validator<BasedSchemaFieldText>;
+export declare const basedSchemaFieldObjectValidator: Validator<BasedSchemaFieldObject>;
+export declare const basedSchemaFieldRecordValidator: Validator<BasedSchemaFieldRecord>;
+export declare const basedSchemaFieldArrayValidator: Validator<BasedSchemaFieldArray>;
+export declare const basedSchemaFieldSetValidator: Validator<BasedSchemaFieldSet>;
+export declare const basedSchemaFieldReferenceValidator: Validator<BasedSchemaFieldReference>;
+export declare const basedSchemaFieldReferencesValidator: Validator<BasedSchemaFieldReferences>;
+export {};