jitar 0.1.1 → 0.1.3

package/src/runtime/serialization/ClassSerializer.ts

@@ -1,133 +0,0 @@
-
-import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
-import Component from '../../core/types/Component.js';
-import FlexObject from '../../core/types/FlexObject.js';
-import Module from '../../core/types/Module.js';
-
-import ModuleLoader from '../utils/ModuleLoader.js';
-import ClassNotFound from './errors/ClassNotFound.js';
-import InvalidClass from './errors/InvalidClass.js';
-import InvalidPropertyType from './errors/InvalidPropertyType.js';
-
-import Serializer from './interfaces/Serializer.js';
-
-import SerializableObject from './types/SerializableObject.js';
-import SerializedClass from './types/SerializedClass.js';
-
-import ValueSerializer from './ValueSerializer.js';
-
-class ClassSerializer implements Serializer
-{
-    serialize(object: SerializableObject): SerializedClass
-    {
-        const clazz = ReflectionHelper.getObjectClass(object);
-        const classFields = ReflectionHelper.getObjectFields(object);
-        const constructParameters = ReflectionHelper.getConstructorParameters(clazz);
-
-        const name = clazz.name;
-        const source = (clazz as Component).source || null;
-        const args: unknown[] = [];
-        const fields: FlexObject = {};
-
-        for (const parameter of constructParameters)
-        {
-            const objectValue = object[parameter.name];
-            const classFieldIndex = classFields.findIndex(field => field.name === parameter.name);
-
-            if (classFieldIndex !== -1)
-            {
-                classFields.splice(classFieldIndex, 1);
-            }
-
-            args.push(ValueSerializer.serialize(objectValue));
-        }
-
-        for (const field of classFields)
-        {
-            if (field.canGetAndSet === false)
-            {
-                // Fields that can't be accessed or updated are ignored.
-                // This is to prevent the serialization of fields that are only used for internal purposes.
-
-                continue;
-            }
-
-            const objectValue = object[field.name];
-
-            fields[field.name] = ValueSerializer.serialize(objectValue);
-        }
-
-        return { serialized: true, name: name, source: source, args: args, fields: fields };
-    }
-
-    async deserialize(object: SerializedClass): Promise<SerializableObject>
-    {
-        this.#validateSerializedClass(object);
-
-        const clazz = await this.#loadClass(object.source, object.name);
-
-        if (clazz === undefined)
-        {
-            throw new ClassNotFound(object.name);
-        }
-
-        if ((clazz instanceof Function) === false)
-        {
-            throw new InvalidClass(object.name);
-        }
-
-        const args = await Promise.all(object.args.map(async (value) => await ValueSerializer.deserialize(value)));
-
-        const instance = ReflectionHelper.createInstance(clazz as Function, args) as SerializableObject;
-
-        for (const name in object.fields)
-        {
-            const fieldValue = object.fields[name];
-
-            instance[name] = await ValueSerializer.deserialize(fieldValue);
-        }
-
-        return instance;
-    }
-
-    #validateSerializedClass(object: SerializedClass): void
-    {
-        if (typeof object.name !== 'string')
-        {
-            throw new InvalidPropertyType('class', 'name', 'string');
-        }
-
-        if (object.source !== null && typeof object.source !== 'string')
-        {
-            throw new InvalidPropertyType(`class '${object.name}'`, 'source', 'string | null');
-        }
-
-        if ((object.args instanceof Array) === false)
-        {
-            throw new InvalidPropertyType(`class '${object.name}'`, 'args', 'Array');
-        }
-
-        if ((object.fields instanceof Object) === false)
-        {
-            throw new InvalidPropertyType(`class '${object.name}'`, 'fields', 'Object');
-        }
-    }
-
-    async #loadClass(source: string | null, name: string): Promise<unknown>
-    {
-        if (source === null)
-        {
-            const system: unknown = typeof window !== 'undefined' ? window : global;
-
-            return (system as Module)[name];
-        }
-
-        const module = await ModuleLoader.load(source);
-
-        return module[name] ?? module.default;
-    }
-}
-
-const instance = new ClassSerializer();
-
-export default instance;

package/src/runtime/serialization/MapSerializer.ts

@@ -1,60 +0,0 @@
-
-import InvalidPropertyType from './errors/InvalidPropertyType.js';
-import Serializer from './interfaces/Serializer.js';
-import SerializedMap from './types/SerializedMap.js';
-
-import ValueSerializer from './ValueSerializer.js';
-
-class MapSerializer implements Serializer
-{
-    serialize(map: Map<unknown, unknown>): SerializedMap
-    {
-        const keys: unknown[] = [];
-        const values: unknown[] = [];
-
-        for (const [key, value] of map)
-        {
-            keys.push(ValueSerializer.serialize(key));
-            values.push(ValueSerializer.serialize(value));
-        }
-
-        return { serialized: true, name: 'Map', entries: { keys: keys, values: values } };
-    }
-
-    async deserialize(object: SerializedMap): Promise<Map<unknown, unknown>>
-    {
-        this.#validateSerializedMap(object);
-
-        const keys = object.entries.keys;
-        const values = object.entries.values;
-
-        const result = new Map();
-
-        for (let index = 0; index < keys.length; index++)
-        {
-            const key = await ValueSerializer.deserialize(keys[index]);
-            const value = await ValueSerializer.deserialize(values[index]);
-
-            result.set(key, value);
-        }
-
-        return result;
-    }
-
-    #validateSerializedMap(object: SerializedMap): void
-    {
-        if ((object.entries?.keys instanceof Array) === false)
-        {
-            throw new InvalidPropertyType('map', 'entries.keys', 'Array');
-        }
-
-        if ((object.entries?.values instanceof Array) === false)
-        {
-            throw new InvalidPropertyType('map', 'entries.values', 'Array');
-        }
-    }
-}
-
-const instance = new MapSerializer();
-
-export default instance;

package/src/runtime/serialization/ObjectSerializer.ts

@@ -1,42 +0,0 @@
-
-import Serializer from './interfaces/Serializer.js';
-
-import SerializableObject from './types/SerializableObject.js';
-import SerializedObject from './types/SerializedObject.js';
-
-import ValueSerializer from './ValueSerializer.js';
-
-class ObjectSerializer implements Serializer
-{
-    serialize(object: SerializableObject): SerializedObject
-    {
-        const result: SerializedObject = {};
-
-        for (const key in object)
-        {
-            const value = object[key];
-
-            result[key] = ValueSerializer.serialize(value);
-        }
-
-        return result;
-    }
-
-    async deserialize(object: SerializedObject): Promise<SerializableObject>
-    {
-        const result: SerializableObject = {};
-
-        for (const key in object)
-        {
-            const value = object[key];
-
-            result[key] = await ValueSerializer.deserialize(value);
-        }
-
-        return result;
-    }
-}
-
-const instance = new ObjectSerializer();
-
-export default instance;

package/src/runtime/serialization/SetSerializer.ts

@@ -1,42 +0,0 @@
-
-import InvalidPropertyType from './errors/InvalidPropertyType.js';
-import Serializer from './interfaces/Serializer.js';
-import SerializedSet from './types/SerializedSet.js';
-
-import ValueSerializer from './ValueSerializer.js';
-
-class SetSerializer implements Serializer
-{
-    serialize(set: Set<unknown>): SerializedSet
-    {
-        const values: unknown[] = [];
-
-        for (const value of set.values())
-        {
-            values.push(ValueSerializer.serialize(value));
-        }
-
-        return { serialized: true, name: 'Set', values: values };
-    }
-
-    async deserialize(object: SerializedSet): Promise<Set<unknown>>
-    {
-        this.#validateSerializedSet(object);
-
-        const values = await Promise.all(object.values.map(async (value: unknown) => await ValueSerializer.deserialize(value)));
-
-        return new Set([...values]);
-    }
-
-    #validateSerializedSet(object: SerializedSet): void
-    {
-        if ((object.values instanceof Array) === false)
-        {
-            throw new InvalidPropertyType('set', 'values', 'Array');
-        }
-    }
-}
-
-const instance = new SetSerializer();
-
-export default instance;

package/src/runtime/serialization/ValueSerializer.ts

@@ -1,81 +0,0 @@
-
-import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
-
-import ArraySerializer from './ArraySerializer.js';
-import ClassSerializer from './ClassSerializer.js';
-import Serializer from './interfaces/Serializer.js';
-import MapSerializer from './MapSerializer.js';
-import ObjectSerializer from './ObjectSerializer.js';
-import SetSerializer from './SetSerializer.js';
-
-import SerializableObject from './types/SerializableObject.js';
-import Serialized from './types/Serialized.js';
-import SerializedClass from './types/SerializedClass.js';
-import SerializedMap from './types/SerializedMap.js';
-import SerializedObject from './types/SerializedObject.js';
-import SerializedSet from './types/SerializedSet.js';
-
-class ValueSerializer implements Serializer
-{
-    serialize(value: unknown): unknown
-    {
-        if (value instanceof Array)
-        {
-            return ArraySerializer.serialize(value);
-        }
-        else if (value instanceof Map)
-        {
-            return MapSerializer.serialize(value);
-        }
-        else if (value instanceof Set)
-        {
-            return SetSerializer.serialize(value);
-        }
-        else if (value instanceof Error)
-        {
-            // The error class is like Array, Map and Set in that it's a native class.
-            // Native classes cannot be defined as a class object by the reflection helper.
-            // Unlike Array, Map and Set, the error class can be serialized by the class serializer.
-
-            // The type casting below isn't pretty, but works for now...
-            return ClassSerializer.serialize(value as unknown as SerializableObject);
-        }
-        else if (value instanceof Object)
-        {
-            return ReflectionHelper.isClassObject(value)
-                ? ClassSerializer.serialize(value as SerializableObject)
-                : ObjectSerializer.serialize(value as SerializableObject);
-        }
-
-        return value;
-    }
-
-    async deserialize(value: unknown): Promise<unknown>
-    {
-        if ((value instanceof Object) === false)
-        {
-            return value;
-        }
-
-        if (value instanceof Array)
-        {
-            return await ArraySerializer.deserialize(value);
-        }
-
-        if ((value as Serialized).serialized !== true)
-        {
-            return await ObjectSerializer.deserialize(value as SerializedObject);
-        }
-
-        switch ((value as Serialized).name)
-        {
-            case 'Map': return await MapSerializer.deserialize(value as SerializedMap);
-            case 'Set': return await SetSerializer.deserialize(value as SerializedSet);
-            default: return await ClassSerializer.deserialize(value as SerializedClass);
-        }
-    }
-}
-
-const instance = new ValueSerializer();
-
-export default instance;

package/src/runtime/serialization/errors/ClassNotFound.ts

@@ -1,12 +0,0 @@
-
-import Component from '../../../core/types/Component.js';
-
-export default class ClassNotFound extends Error
-{
-    constructor(name: string)
-    {
-        super(`The class '${name}' could not be found`);
-    }
-}
-
-(ClassNotFound as Component).source = '/jitar/runtime/serialization/errors/ClassNotFound.js';

package/src/runtime/serialization/errors/InvalidClass.ts

@@ -1,12 +0,0 @@
-
-import Component from '../../../core/types/Component.js';
-
-export default class InvalidClass extends Error
-{
-    constructor(name: string)
-    {
-        super(`The class '${name}' is invalid`);
-    }
-}
-
-(InvalidClass as Component).source = '/jitar/runtime/serialization/errors/InvalidClass.js';

package/src/runtime/serialization/errors/InvalidPropertyType.ts

@@ -1,12 +0,0 @@
-
-import Component from '../../../core/types/Component.js';
-
-export default class InvalidPropertyType extends Error
-{
-    constructor(typeName: string, propertyName: string, expectedType: string)
-    {
-        super(`The ${typeName} property '${propertyName}' has an invalid type (expected '${expectedType}')`);
-    }
-}
-
-(InvalidPropertyType as Component).source = '/jitar/runtime/serialization/errors/InvalidPropertyType.js';

package/src/runtime/serialization/interfaces/Serializer.ts

@@ -1,10 +0,0 @@
-
-// Static functions are not supported in typescript.
-// Therefore all implementations need to export a singleton instance.
-
-export default interface Serializer
-{
-    serialize(value: unknown): unknown;
-
-    deserialize(value: unknown): Promise<unknown>;
-}

package/src/runtime/serialization/types/SerializableObject.ts

@@ -1,6 +0,0 @@
-
-import FlexObject from '../../../core/types/FlexObject.js';
-
-type SerializableObject = FlexObject;
-
-export default SerializableObject;

package/src/runtime/serialization/types/Serialized.ts

@@ -1,8 +0,0 @@
-
-type Serialized =
-    {
-        serialized: boolean,
-        name: string
-    };
-
-export default Serialized;

package/src/runtime/serialization/types/SerializedClass.ts

@@ -1,13 +0,0 @@
-
-import FlexObject from '../../../core/types/FlexObject.js';
-
-import Serialized from './Serialized.js';
-
-type SerializedClass = Serialized &
-{
-    source: string | null,
-    args: unknown[],
-    fields: FlexObject
-}
-
-export default SerializedClass;

package/src/runtime/serialization/types/SerializedMap.ts

@@ -1,13 +0,0 @@
-
-import Serialized from './Serialized.js';
-
-type SerializedMap = Serialized &
-{
-    entries:
-    {
-        keys: unknown[],
-        values: unknown[]
-    }
-}
-
-export default SerializedMap;

package/src/runtime/serialization/types/SerializedObject.ts

@@ -1,4 +0,0 @@
-
-type SerializedObject = { [key: string]: unknown };
-
-export default SerializedObject;

package/src/runtime/serialization/types/SerializedSet.ts

@@ -1,9 +0,0 @@
-
-import Serialized from './Serialized.js';
-
-type SerializedSet = Serialized &
-{
-    values: unknown[]
-}
-
-export default SerializedSet;

package/src/runtime/types/JitarHooks.ts

@@ -1,10 +0,0 @@
-
-import Runtime from '../Runtime.js';
-
-type JitarHooks =
-    {
-        setRuntime: (runtime: Runtime) => void;
-        setDependencyLoader: (loader: Function) => void;
-    }
-
-export default JitarHooks;

package/src/runtime/types/ModuleImporter.ts

@@ -1,6 +0,0 @@
-
-import Module from '../../core/types/Module.js';
-
-type ModuleImporter = (name: string) => Promise<Module>;
-
-export default ModuleImporter;

package/src/runtime/utils/ModuleAnalyser.ts

@@ -1,60 +0,0 @@
-
-import Module from '../../core/types/Module.js';
-
-export default class ModuleAnalyser
-{
-    static filterObjects(module: Module): Map<string, Object>
-    {
-        return this.#filterexported(module, Object);
-    }
-
-    static filterFunctions(module: Module): Map<string, Function>
-    {
-        const functions = this.#filterexported(module, Function);
-
-        return this.#filterFunctionTypes(functions, false);
-    }
-
-    static filterClasses(module: Module): Map<string, Function>
-    {
-        const functions = this.#filterexported(module, Function);
-
-        return this.#filterFunctionTypes(functions, true);
-    }
-
-    static #filterexported(module: Module, type: ReturnType<typeof Function>): Map<string, typeof Function>
-    {
-        const keys = Object.keys(module);
-
-        const filtered = new Map();
-
-        for (const key of keys)
-        {
-            const exported = module[key];
-
-            if (exported instanceof type)
-            {
-                filtered.set(key, exported);
-            }
-        }
-
-        return filtered;
-    }
-
-    static #filterFunctionTypes(functions: Map<string, Function>, filterClasses: boolean): Map<string, Function>
-    {
-        const filtered = new Map();
-
-        for (const [key, value] of functions)
-        {
-            const code = value.toString();
-
-            if (code.startsWith('class') === filterClasses)
-            {
-                filtered.set(key, value);
-            }
-        }
-
-        return filtered;
-    }
-}

package/src/runtime/utils/ModuleLoader.ts

@@ -1,51 +0,0 @@
-
-import Module from '../../core/types/Module.js';
-
-import ModuleNotLoaded from '../errors/ModuleNotLoaded.js';
-import ModuleImporter from '../types/ModuleImporter.js';
-import UrlRewriter from './UrlRewriter.js';
-
-let _baseUrl: string | undefined;
-let _import = async (name: string): Promise<Module> => { return import(name); };
-
-export default class ModuleLoader
-{
-    static setBaseUrl(baseUrl: string): void
-    {
-        _baseUrl = baseUrl;
-    }
-
-    static setImporter(importer: ModuleImporter): void
-    {
-        _import = importer;
-    }
-
-    static async load(url: string): Promise<Module>
-    {
-        if (url.startsWith('/jitar'))
-        {
-            url = `../../${url}`;
-        }
-
-        if (_baseUrl !== undefined && url.startsWith(_baseUrl) === false)
-        {
-            url = UrlRewriter.addBase(url, _baseUrl);
-        }
-
-        return this.import(url) as Promise<Module>;
-    }
-
-    static async import(specifier: string)
-    {
-        try
-        {
-            return await _import(specifier);
-        }
-        catch (error: unknown)
-        {
-            const message = error instanceof Error ? error.message : String(error);
-
-            throw new ModuleNotLoaded(specifier, message);
-        }
-    }
-}

package/src/runtime/utils/UrlRewriter.ts

@@ -1,59 +0,0 @@
-
-export default class UrlRewriter
-{
-    static addBase(url: string, base: string): string
-    {
-        url = this.#ensureStartsWithoutSlash(url);
-        base = this.#assureEndWithSlash(base);
-
-        return this.#translateRelativeParts(`${base}${url}`);
-    }
-
-    static #ensureStartsWithoutSlash(url: string): string
-    {
-        if (url.startsWith('/'))
-        {
-            return url.substring(1);
-        }
-
-        return url;
-    }
-
-    static #assureEndWithSlash(base: string): string
-    {
-        if (base.endsWith('/'))
-        {
-            return base;
-        }
-
-        return `${base}/`;
-    }
-
-    static #translateRelativeParts(url: string)
-    {
-        const parts = url.split('/');
-        const translated = [];
-
-        translated.push(parts[0]);
-
-        for (let index = 1; index < parts.length; index++)
-        {
-            const part = parts[index].trim();
-
-            if (part === '.' || part === '')
-            {
-                continue;
-            }
-            else if (part === '..')
-            {
-                translated.pop();
-
-                continue;
-            }
-
-            translated.push(part);
-        }
-
-        return translated.join('/');
-    }
-}