@based/schema 2.6.0 → 2.7.0

package/dist/src/compat/Untitled-1.d.ts

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

package/dist/src/compat/Untitled-1.js

@@ -0,0 +1,205 @@
+const metaChecker = (field) => {
+    return (field === 'validation' ||
+        field === 'format' ||
+        field === 'index' ||
+        field === 'description' ||
+        field === 'title' ||
+        field === 'examples' ||
+        field === 'ui' ||
+        field === 'isRequired' ||
+        field === 'title' ||
+        field === 'description' ||
+        field === 'index' ||
+        field === 'readOnly' ||
+        field === 'writeOnly' ||
+        field === '$comment' ||
+        field === 'examples' ||
+        field === 'default' ||
+        field === 'customValidator' ||
+        field === 'value' ||
+        field === 'path' ||
+        field === 'target' ||
+        field === 'minLength' ||
+        field === 'maxLength' ||
+        field === 'contentMediaEncoding' ||
+        field === 'pattern' ||
+        field === 'display' ||
+        field === 'multiline' ||
+        field === 'multipleOf' ||
+        field === 'minimum' ||
+        field === 'maximum' ||
+        field === 'exclusiveMaximum' ||
+        field === 'exclusiveMinimum' ||
+        field === '$delete');
+};
+const excludedFields = (field) => {
+    return field === 'language' || field === 'translations' || field === '$defs';
+};
+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 {
+                tmp[i] = obj[i];
+            }
+        }
+    }
+    return Object.keys({ meta: tmp }.meta).length > 0 ? { meta: tmp } : null;
+};
+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',
+                items: 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 {
+                format: 'strongPassword',
+                type: 'string',
+            };
+        case 'id':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'url':
+            return {
+                ...metaParser(oldField),
+                format: 'URL',
+                type: 'string',
+            };
+        case 'email':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'phone':
+            return {
+                format: 'mobilePhone',
+                type: 'string',
+            };
+        case 'geo':
+            return {
+                format: 'latLong',
+                type: 'string',
+            };
+        case 'type':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        default:
+            return {
+                ...metaParser(oldField),
+                type: oldField.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: {},
+    };
+    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;
+};
+export const convertNewToOld222 = (schema) => {
+    const tmpSchema = migrateTypes(schema);
+    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    tmpSchema.languages = [schema.language, ...schema?.translations];
+    delete tmpSchema.root;
+    return tmpSchema;
+};
+//# sourceMappingURL=Untitled-1.js.map

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,182 @@ 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({ meta: tmp }.meta).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),
+            };
         }
     }
+    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 = [schema.language, ...schema?.translations];
+    tmpSchema.rootType = convertRoot(schema);
+    delete tmpSchema.root;
     return tmpSchema;
 };
 //# sourceMappingURL=newToOld.js.map

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;