@based/schema 2.6.0 → 2.7.1

package/dist/src/compat/newToOld.d.ts

@@ -1,3 +1,3 @@
-import { BasedSchema } from '../types.js';
 import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertNewToOld: (schema: BasedSchema) => Partial<BasedOldSchema>;
+import { BasedSchemaPartial } from '../types.js';
+export declare const convertNewToOld: (schema: BasedSchemaPartial) => Partial<BasedOldSchema>;

package/dist/src/compat/newToOld.js

@@ -1,6 +1,8 @@
+// import { BasedSchema } from '../types.js'
+// import { BasedOldSchema } from './oldSchemaType.js'
 const metaChecker = (field) => {
     return (field === 'validation' ||
-        field === 'format' ||
+        // field === 'format' ||
         field === 'index' ||
         field === 'description' ||
         field === 'title' ||
@@ -30,47 +32,188 @@ const metaChecker = (field) => {
         field === 'maximum' ||
         field === 'exclusiveMaximum' ||
         field === 'exclusiveMinimum' ||
-        field === '$delete');
+        field === '$delete' ||
+        field === 'display');
 };
 const excludedFields = (field) => {
     return field === 'language' || field === 'translations' || field === '$defs';
 };
-export const convertNewToOld = (schema) => {
-    const tmpSchema = {};
-    const walker = (target, source) => {
-        for (const i in source) {
-            if (source[i] && typeof source[i] === 'object' && i in target === false) {
-                target[i] = source[i].length ? [] : {};
-                walker(target[i], source[i]);
+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 tmp = {};
+    for (const i in obj) {
+        if (metaChecker(i)) {
+            if (i === 'title') {
+                tmp.name = obj[i];
             }
-            else if (!metaChecker(i)) {
-                target[i] = source[i];
+            else if (obj[i] === 'bytes') {
+                tmp.format = obj[i];
             }
             else {
-                target.meta = {};
-                for (const i in source) {
-                    if (metaChecker(i) && typeof source[i] !== 'object') {
-                        if (i === 'title') {
-                            target.meta = { ...target.meta, name: source[i] };
-                        }
-                        else {
-                            target.meta = { ...target.meta, [i]: source[i] };
-                        }
-                        delete source[i];
-                    }
+                tmp[i] = obj[i];
+            }
+        }
+    }
+    return Object.keys(tmp).length > 0 ? { meta: tmp } : null;
+};
+const migrateField = (field) => {
+    if (field?.type === 'object') {
+        return {
+            ...metaParser(field),
+            type: 'object',
+            properties: migrateFields(field.properties, true),
+        };
+    }
+    else if (field?.type === 'json') {
+        return {
+            ...field,
+            ...metaParser(field),
+            type: 'json',
+        };
+    }
+    else if (field?.type === 'array') {
+        const values = migrateField(field.values);
+        if (!values) {
+            return null;
+        }
+        return {
+            ...metaParser(field),
+            type: 'array',
+            items: values,
+        };
+    }
+    else if (field?.type === 'set') {
+        return {
+            ...metaParser(field),
+            type: 'set',
+            items: migrateField(field.items),
+        };
+    }
+    else if (field?.type === 'record') {
+        return {
+            ...metaParser(field),
+            type: 'record',
+            values: migrateField(field.values),
+        };
+    }
+    else if (field?.type === 'reference' || field?.type === 'references') {
+        return {
+            ...metaParser(field),
+            type: field?.type,
+            ...(field.bidirectional ? { bidirectional: field.bidirectional } : null),
+        };
+    }
+    else if (field?.type === 'integer') {
+        return {
+            ...metaParser(field),
+            type: 'int',
+        };
+    }
+    else if (field?.format === 'strongPassword') {
+        return { ...metaParser(field), type: 'digest' };
+    }
+    else if (field?.format === 'basedId') {
+        return { ...metaParser(field), type: 'id' };
+    }
+    else if (field?.format === 'URL') {
+        return { ...metaParser(field), type: 'url' };
+    }
+    else if (field?.format === 'email') {
+        return {
+            ...metaParser(field),
+            type: 'email',
+        };
+    }
+    else if (field?.format === 'mobilePhone') {
+        return {
+            ...metaParser(field),
+            type: 'phone',
+        };
+    }
+    else if (field?.format === 'latLong') {
+        return {
+            ...metaParser(field),
+            type: 'geo',
+        };
+    }
+    else {
+        return { ...metaParser(field), type: field?.type };
+    }
+};
+const migrateFields = (oldFields, recursing = false) => {
+    const result = {};
+    if (oldFields) {
+        for (const key in oldFields) {
+            if (oldFields.hasOwnProperty(key)) {
+                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: {},
     };
-    walker(tmpSchema, schema);
-    if ((tmpSchema.meta = {}))
-        delete tmpSchema.meta;
-    for (const i in tmpSchema) {
-        if (excludedFields(i)) {
-            delete tmpSchema[i];
+    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),
+            };
         }
     }
-    tmpSchema.languages = [schema.language, ...schema?.translations];
+    return result;
+};
+const convertRoot = (schema) => {
+    const result = {
+        fields: {},
+        ...metaParser(schema.root),
+        ...(schema.root?.prefix ? { prefix: schema.root.prefix } : null),
+    };
+    for (const i in schema.root?.fields) {
+        const field = schema.root?.fields[i];
+        result.fields[i] = {
+            ...metaParser(field),
+            ...migrateField(field),
+        };
+    }
+    return result;
+};
+export const convertNewToOld = (schema) => {
+    const tmpSchema = migrateTypes(schema);
+    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    tmpSchema.languages = [];
+    if (schema.language) {
+        tmpSchema.languages.push(schema.language);
+    }
+    if (schema.translations) {
+        tmpSchema.languages.push(...schema.translations);
+    }
+    tmpSchema.rootType = convertRoot(schema);
+    delete tmpSchema.root;
     return tmpSchema;
 };
 //# sourceMappingURL=newToOld.js.map

package/dist/src/compat/oldToNew.d.ts

@@ -1,3 +1,3 @@
 import { BasedSchema } from '../types.js';
 import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertOldToNew: (oldSchema: BasedOldSchema) => BasedSchema;
+export declare const convertOldToNew: (oldSchema: Partial<BasedOldSchema>) => BasedSchema;

package/dist/src/compat/oldToNew.js

@@ -1,35 +1,210 @@
-export const convertOldToNew = (oldSchema) => {
-    const tempSchema = {};
-    const walker = (source, target) => {
-        for (const i in source) {
-            if (i === 'languages' && source[i].length) {
-                target.language = source[i][0];
-                target.translations = source[i].filter((_, i) => i !== 0);
+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;
             }
-            else if (typeof source[i] === 'object' && i in target === false) {
-                if (i === 'meta' &&
-                    !Object.keys(source[i]).includes('properties' || 'type')) {
-                    for (const j in source[i]) {
-                        if (j === 'name') {
-                            target.title = source[i][j];
-                        }
-                        else {
-                            target[j] = source[i][j];
-                        }
-                    }
+            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;
                 }
-                else {
-                    target[i] = source[i].length ? [] : {};
-                    walker(source[i], target[i]);
+                const field = migrateField(oldFields[key]);
+                if (!field) {
+                    continue;
                 }
+                result[key] = field;
             }
-            else if (i !== 'meta') {
-                target[i] = source[i];
-            }
         }
+    }
+    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),
     };
-    walker(oldSchema, tempSchema);
+    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,5 @@
 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';

package/dist/src/index.js

@@ -1,5 +1,5 @@
 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';

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 {};