jitar 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import LocalNode from './runtime/LocalNode.js';
+export declare function startClient(...segmentFiles: string[]): Promise<LocalNode>;

package/dist/client.js

@@ -0,0 +1,12 @@
+import LocalNode from './runtime/LocalNode.js';
+import RemoteGateway from './runtime/RemoteGateway.js';
+import RemoteRepository from './runtime/RemoteRepository.js';
+export async function startClient(...segmentFiles) {
+    const remoteUrl = document.location.origin;
+    const node = new LocalNode();
+    const gateway = new RemoteGateway(remoteUrl);
+    const repository = new RemoteRepository(remoteUrl);
+    await node.setGateway(gateway);
+    await node.setRepository(repository, segmentFiles);
+    return node;
+}

package/dist/core/AccessLevel.d.ts

@@ -0,0 +1,5 @@
+declare enum AccessLevel {
+    PRIVATE = "private",
+    PUBLIC = "public"
+}
+export default AccessLevel;

package/dist/core/AccessLevel.js

@@ -0,0 +1,6 @@
+var AccessLevel;
+(function (AccessLevel) {
+    AccessLevel["PRIVATE"] = "private";
+    AccessLevel["PUBLIC"] = "public";
+})(AccessLevel || (AccessLevel = {}));
+export default AccessLevel;

package/dist/core/ErrorManager.d.ts

@@ -0,0 +1,3 @@
+export default class ErrorManager {
+    static handle(error: unknown, name: string, version: string): Error;
+}

package/dist/core/ErrorManager.js

@@ -0,0 +1,11 @@
+export default class ErrorManager {
+    static handle(error, name, version) {
+        const parentMessage = error instanceof Error ? error.message : String(error);
+        const newMessage = `${parentMessage}\n[${name} | v${version}]`;
+        if (error instanceof Error) {
+            error.message = newMessage;
+            return error;
+        }
+        return new Error(newMessage);
+    }
+}

package/dist/core/Implementation.d.ts

@@ -0,0 +1,10 @@
+import ReflectionParameter from './reflection/models/ReflectionParameter.js';
+import Version from './Version.js';
+export default class Implementation {
+    #private;
+    constructor(version: Version, access: string, parameters: ReflectionParameter[], executable: Function);
+    get version(): Version;
+    get public(): boolean;
+    get parameters(): ReflectionParameter[];
+    run(args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/core/Implementation.js

@@ -0,0 +1,32 @@
+import MissingParameterValue from './errors/MissingParameterValue.js';
+import * as AccessLevel from './definitions/AccessLevel.js';
+export default class Implementation {
+    #version;
+    #access;
+    #parameters;
+    #executable;
+    constructor(version, access, parameters, executable) {
+        this.#version = version;
+        this.#access = access;
+        this.#parameters = parameters;
+        this.#executable = executable;
+    }
+    get version() { return this.#version; }
+    get public() { return this.#access === AccessLevel.PUBLIC; }
+    get parameters() { return this.#parameters; }
+    async run(args) {
+        const values = this.#extractParameterValues(args);
+        return await this.#executable.call(this.#executable, ...values);
+    }
+    #extractParameterValues(parameters) {
+        const values = [];
+        for (const parameter of this.#parameters) {
+            const value = parameters.get(parameter.name);
+            if (value === undefined && parameter.isOptional === false) {
+                throw new MissingParameterValue(parameter.name);
+            }
+            values.push(value);
+        }
+        return values;
+    }
+}

package/dist/core/ImplementationBuilder.d.ts

@@ -0,0 +1,4 @@
+import Implementation from './Implementation.js';
+export default class ImplementationBuilder {
+    static build(executable: Function): Implementation;
+}

package/dist/core/ImplementationBuilder.js

@@ -0,0 +1,14 @@
+import Implementation from './Implementation.js';
+import ReflectionHelper from './reflection/ReflectionHelper.js';
+import Version from './Version.js';
+export default class ImplementationBuilder {
+    static build(executable) {
+        const component = executable;
+        const name = component.name;
+        const module = component.module ?? '';
+        const version = component.version ? Version.parse(component.version) : Version.DEFAULT;
+        const isPublic = component.public !== false;
+        const parameters = ReflectionHelper.getFunctionParameters(executable);
+        return new Implementation(name, module, version, isPublic, parameters, executable);
+    }
+}

package/dist/core/Procedure.d.ts

@@ -0,0 +1,13 @@
+import Implementation from './Implementation.js';
+import Version from './Version.js';
+export default class Procedure {
+    #private;
+    constructor(module: string, name: string);
+    get module(): string;
+    get name(): string;
+    get fqn(): string;
+    get public(): boolean;
+    addImplementation(implementation: Implementation): void;
+    getImplementation(version: Version): Implementation | undefined;
+    run(version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/core/Procedure.js

@@ -0,0 +1,58 @@
+import ImplementationNotFound from './errors/ImplementationNotFound.js';
+import FqnBuilder from './utils/FqnBuilder.js';
+import Version from './Version.js';
+export default class Procedure {
+    #module;
+    #name;
+    #fqn;
+    #implementations = new Map();
+    #latestImplementation;
+    constructor(module, name) {
+        this.#module = module;
+        this.#name = name;
+        this.#fqn = FqnBuilder.build(module, name);
+    }
+    get module() { return this.#module; }
+    get name() { return this.#name; }
+    get fqn() { return this.#fqn; }
+    get public() {
+        const implementations = [...this.#implementations.values()];
+        return implementations.some(implementation => implementation.public);
+    }
+    addImplementation(implementation) {
+        this.#implementations.set(implementation.version, implementation);
+        if (this.#isNewLatestImplementation(implementation)) {
+            this.#latestImplementation = implementation;
+        }
+    }
+    #isNewLatestImplementation(implementation) {
+        return this.#latestImplementation === undefined
+            || implementation.version.greater(this.#latestImplementation.version);
+    }
+    getImplementation(version) {
+        const selectedVersion = this.#selectAvailableVersion(version);
+        return this.#implementations.get(selectedVersion);
+    }
+    #selectAvailableVersion(version) {
+        let selectedVersion = Version.DEFAULT;
+        for (const implementationVersion of this.#implementations.keys()) {
+            if (implementationVersion.equals(version)) {
+                return implementationVersion;
+            }
+            if (implementationVersion.greater(version)) {
+                continue;
+            }
+            if (selectedVersion.less(implementationVersion)) {
+                selectedVersion = implementationVersion;
+            }
+        }
+        return selectedVersion;
+    }
+    async run(version, args) {
+        const implementation = this.getImplementation(version);
+        if (implementation === undefined) {
+            throw new ImplementationNotFound(this.fqn, version.toString());
+        }
+        return implementation.run(args);
+    }
+}

package/dist/core/Segment.d.ts

@@ -0,0 +1,13 @@
+import Runner from './interfaces/Runner.js';
+import Procedure from './Procedure.js';
+import Version from './Version.js';
+export default class Segment implements Runner {
+    #private;
+    constructor(id: string);
+    get id(): string;
+    addProcedure(procedure: Procedure): void;
+    hasProcedure(fqn: string): boolean;
+    getProcedure(fqn: string): Procedure | undefined;
+    getPublicProcedures(): Procedure[];
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/core/Segment.js

@@ -0,0 +1,36 @@
+import ErrorManager from './ErrorManager.js';
+import ProcedureNotFound from './errors/ProcedureNotFound.js';
+export default class Segment {
+    #id;
+    #procedures = new Map();
+    constructor(id) {
+        this.#id = id;
+    }
+    get id() { return this.#id; }
+    addProcedure(procedure) {
+        this.#procedures.set(procedure.fqn, procedure);
+    }
+    hasProcedure(fqn) {
+        const procedure = this.getProcedure(fqn);
+        return procedure !== undefined;
+    }
+    getProcedure(fqn) {
+        return this.#procedures.get(fqn);
+    }
+    getPublicProcedures() {
+        const procedures = [...this.#procedures.values()];
+        return procedures.filter(procedure => procedure.public);
+    }
+    async run(fqn, version, args) {
+        const procedure = this.getProcedure(fqn);
+        if (procedure === undefined) {
+            throw new ProcedureNotFound(fqn);
+        }
+        try {
+            return await procedure.run(version, args);
+        }
+        catch (error) {
+            throw ErrorManager.handle(error, fqn, version.toString());
+        }
+    }
+}

package/dist/core/SegmentBuilder.d.ts

@@ -0,0 +1,6 @@
+import SegmentModule from './types/SegmentModule.js';
+import Segment from './Segment.js';
+export default class SegmentBuilder {
+    #private;
+    static build(id: string, module: SegmentModule): Segment;
+}

package/dist/core/SegmentBuilder.js

@@ -0,0 +1,33 @@
+import ReflectionHelper from './reflection/ReflectionHelper.js';
+import Implementation from './Implementation.js';
+import Procedure from './Procedure.js';
+import Segment from './Segment.js';
+import Version from './Version.js';
+export default class SegmentBuilder {
+    static build(id, module) {
+        const segment = new Segment(id);
+        for (const definition of module.procedures) {
+            const procedure = this.#buildProcedure(definition);
+            segment.addProcedure(procedure);
+        }
+        ;
+        return segment;
+    }
+    static #buildProcedure(definition) {
+        const module = definition.module;
+        const name = definition.name;
+        const procedure = new Procedure(module, name);
+        for (const implementationDefinition of definition.implementations) {
+            const implementation = this.#buildImplementation(implementationDefinition);
+            procedure.addImplementation(implementation);
+        }
+        return procedure;
+    }
+    static #buildImplementation(definition) {
+        const version = Version.parse(definition.version);
+        const access = definition.access;
+        const executable = definition.executable;
+        const parameters = ReflectionHelper.getFunctionParameters(executable);
+        return new Implementation(version, access, parameters, executable);
+    }
+}

package/dist/core/Version.d.ts

@@ -0,0 +1,13 @@
+export default class Version {
+    #private;
+    static get DEFAULT(): Version;
+    constructor(major?: number, minor?: number, patch?: number);
+    get major(): number;
+    get minor(): number;
+    get patch(): number;
+    equals(version: Version): boolean;
+    greater(version: Version): boolean;
+    less(version: Version): boolean;
+    toString(): string;
+    static parse(number: string): Version;
+}

package/dist/core/Version.js

@@ -0,0 +1,50 @@
+import InvalidVersionNumber from './errors/InvalidVersionNumber.js';
+export default class Version {
+    static get DEFAULT() { return new Version(0, 0, 0); }
+    #major;
+    #minor;
+    #patch;
+    constructor(major = 0, minor = 0, patch = 0) {
+        this.#major = major;
+        this.#minor = minor;
+        this.#patch = patch;
+    }
+    get major() { return this.#major; }
+    get minor() { return this.#minor; }
+    get patch() { return this.#patch; }
+    equals(version) {
+        return this.#major === version.major
+            && this.#minor === version.minor
+            && this.#patch === version.patch;
+    }
+    greater(version) {
+        if (this.#major !== version.major)
+            return this.#major > version.major;
+        if (this.#minor !== version.minor)
+            return this.#minor > version.minor;
+        if (this.#patch !== version.patch)
+            return this.#patch > version.patch;
+        return false;
+    }
+    less(version) {
+        if (this.#major !== version.major)
+            return this.#major < version.major;
+        if (this.#minor !== version.minor)
+            return this.#minor < version.minor;
+        if (this.#patch !== version.patch)
+            return this.#patch < version.patch;
+        return false;
+    }
+    toString() {
+        return `${this.#major}.${this.#minor}.${this.#patch}`;
+    }
+    static parse(number) {
+        const parts = number.split('.');
+        switch (parts.length) {
+            case 1: return new Version(Number.parseInt(parts[0]));
+            case 2: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]));
+            case 3: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]), Number.parseInt(parts[2]));
+            default: throw new InvalidVersionNumber(number);
+        }
+    }
+}

package/dist/core/definitions/AccessLevel.d.ts

@@ -0,0 +1,2 @@
+export declare const PRIVATE = "private";
+export declare const PUBLIC = "public";

package/dist/core/definitions/AccessLevel.js

@@ -0,0 +1,2 @@
+export const PRIVATE = 'private';
+export const PUBLIC = 'public';

package/dist/core/errors/ErrorManager.d.ts

@@ -0,0 +1,3 @@
+export default class ErrorManager extends Error {
+    static handle(error: unknown, name: string, version: string): Error;
+}

package/dist/core/errors/ErrorManager.js

@@ -0,0 +1,11 @@
+export default class ErrorManager extends Error {
+    static handle(error, name, version) {
+        const parentMessage = error instanceof Error ? error.message : String(error);
+        const newMessage = `${parentMessage}\n[${name} | v${version}]`;
+        if (error instanceof Error) {
+            error.message = newMessage;
+            return error;
+        }
+        return new Error(newMessage);
+    }
+}

package/dist/core/errors/ImplementationNotFound.d.ts

@@ -0,0 +1,3 @@
+export default class ImplementationNotFound extends Error {
+    constructor(fqn: string, version: string);
+}

package/dist/core/errors/ImplementationNotFound.js

@@ -0,0 +1,6 @@
+export default class ImplementationNotFound extends Error {
+    constructor(fqn, version) {
+        super(`No implementation found for procedure '${fqn}' with version '${version}'`);
+    }
+}
+ImplementationNotFound.source = '/jitar/core/errors/ImplementationNotFound.js';

package/dist/core/errors/InvalidVersionNumber.d.ts

@@ -0,0 +1,3 @@
+export default class InvalidVersionNumber extends Error {
+    constructor(number: string);
+}

package/dist/core/errors/InvalidVersionNumber.js

@@ -0,0 +1,6 @@
+export default class InvalidVersionNumber extends Error {
+    constructor(number) {
+        super(`Invalid version number '${number}'`);
+    }
+}
+InvalidVersionNumber.source = '/jitar/core/errors/InvalidVersionNumber.js';

package/dist/core/errors/MissingParameterValue.d.ts

@@ -0,0 +1,3 @@
+export default class MissingParameterValue extends Error {
+    constructor(parameterName: string);
+}

package/dist/core/errors/MissingParameterValue.js

@@ -0,0 +1,6 @@
+export default class MissingParameterValue extends Error {
+    constructor(parameterName) {
+        super(`Missing value for parameter '${parameterName}'`);
+    }
+}
+MissingParameterValue.source = '/jitar/core/errors/MissingParameterValue.js';

package/dist/core/errors/NotImplemented.d.ts

@@ -0,0 +1,3 @@
+export default class NotImplemented extends Error {
+    constructor();
+}

package/dist/core/errors/NotImplemented.js

@@ -0,0 +1,6 @@
+export default class NotImplemented extends Error {
+    constructor() {
+        super('Not implemented');
+    }
+}
+NotImplemented.source = '/jitar/core/errors/NotImplemented.js';

package/dist/core/errors/ProcedureNotFound.d.ts

@@ -0,0 +1,3 @@
+export default class ProcedureNotFound extends Error {
+    constructor(fqn: string);
+}

package/dist/core/errors/ProcedureNotFound.js

@@ -0,0 +1,6 @@
+export default class ProcedureNotFound extends Error {
+    constructor(fqn) {
+        super(`Procedure '${fqn}' not found`);
+    }
+}
+ProcedureNotFound.source = '/jitar/core/errors/ProcedureNotFound.js';

package/dist/core/interfaces/Runner.d.ts

@@ -0,0 +1,4 @@
+import Version from '../Version.js';
+export default interface Runner {
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/core/interfaces/Runner.js

@@ -0,0 +1 @@
+export {};

package/dist/core/reflection/ParameterParser.d.ts

@@ -0,0 +1,5 @@
+import ReflectionParameter from './models/ReflectionParameter.js';
+export default class ParameterParser {
+    #private;
+    static parse(code: string, functionIndicator: string): ReflectionParameter[];
+}

package/dist/core/reflection/ParameterParser.js

@@ -0,0 +1,51 @@
+import ReflectionParameter from './models/ReflectionParameter.js';
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+export default class ParameterParser {
+    static parse(code, functionIndicator) {
+        const pureCode = this.#removeComments(code);
+        const parameterString = this.#extractParameterString(pureCode, functionIndicator);
+        const parameterList = this.#parseParamaterString(parameterString);
+        return parameterList.map(parameter => this.#extractParameter(parameter));
+    }
+    static #removeComments(code) {
+        return code.replace(STRIP_COMMENTS, '');
+    }
+    static #extractParameterString(code, functionIndicator) {
+        const indicatorPosition = code.indexOf(functionIndicator);
+        const bodyStart = code.indexOf('{', indicatorPosition);
+        const definition = code.substring(indicatorPosition, bodyStart).trim();
+        const startPosition = definition.indexOf('(') + 1;
+        const endPosition = definition.lastIndexOf(')', startPosition);
+        return definition.slice(startPosition, endPosition);
+    }
+    static #parseParamaterString(parameterString) {
+        const parameters = [];
+        let level = 0;
+        let buffer = '';
+        for (let character of parameterString) {
+            switch (character) {
+                case '(':
+                    level++;
+                    break;
+                case ')':
+                    level--;
+                    break;
+                case ',':
+                    if (level === 0) {
+                        parameters.push(buffer);
+                        character = '';
+                        buffer = '';
+                    }
+            }
+            buffer += character;
+        }
+        if (buffer !== '') {
+            parameters.push(buffer);
+        }
+        return parameters;
+    }
+    static #extractParameter(parameter) {
+        const [name, defaultValue] = parameter.split('=').map(part => part.trim());
+        return new ReflectionParameter(name, defaultValue);
+    }
+}

package/dist/core/reflection/ReflectionHelper.d.ts

@@ -0,0 +1,13 @@
+import ReflectionField from './models/ReflectionField.js';
+import ReflectionParameter from './models/ReflectionParameter.js';
+export default class ReflectionHelper {
+    #private;
+    static createInstance(clazz: Function, args?: unknown[]): object;
+    static isClassObject(object: object): boolean;
+    static getObjectClass(object: object): Function;
+    static getParentClass(clazz: Function): Function;
+    static getFields(clazz: Function): ReflectionField[];
+    static getObjectFields(object: object): ReflectionField[];
+    static getConstructorParameters(clazz: Function): ReflectionParameter[];
+    static getFunctionParameters(funktion: Function): ReflectionParameter[];
+}

package/dist/core/reflection/ReflectionHelper.js

@@ -0,0 +1,69 @@
+import ReflectionField from './models/ReflectionField.js';
+import ParameterParser from './ParameterParser.js';
+const CONSTRUCTOR_NAME = 'constructor';
+const FUNCTION_NAME = 'function';
+export default class ReflectionHelper {
+    static createInstance(clazz, args = []) {
+        return new clazz(...args);
+    }
+    static isClassObject(object) {
+        return object.constructor.toString().startsWith('class');
+    }
+    static getObjectClass(object) {
+        return object.constructor;
+    }
+    static getParentClass(clazz) {
+        return Object.getPrototypeOf(clazz);
+    }
+    static getFields(clazz) {
+        const object = this.createInstance(clazz);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+        return [...publicFields, ...propertyFields];
+    }
+    static getObjectFields(object) {
+        const clazz = this.getObjectClass(object);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+        return [...publicFields, ...propertyFields];
+    }
+    static #getPublicFields(object) {
+        const fieldNames = Object.getOwnPropertyNames(object);
+        return fieldNames.map(fieldName => new ReflectionField(fieldName, true, true));
+    }
+    static #getPropertyFields(clazz) {
+        const methods = Object.getOwnPropertyDescriptors(clazz.prototype);
+        const fields = [];
+        for (const name in methods) {
+            const description = methods[name];
+            const hasGetter = description.get !== undefined;
+            const hasSetter = description.set !== undefined;
+            if (hasGetter === false && hasSetter === false) {
+                continue;
+            }
+            fields.push(new ReflectionField(name, hasGetter, hasSetter));
+        }
+        const parentClazz = this.getParentClass(clazz);
+        if (parentClazz.name !== '') {
+            const parentFields = this.#getPropertyFields(parentClazz);
+            return [...fields, ...parentFields];
+        }
+        return fields;
+    }
+    static getConstructorParameters(clazz) {
+        const code = clazz.toString();
+        const hasConstructor = code.includes(CONSTRUCTOR_NAME);
+        if (hasConstructor === false) {
+            const parentClazz = this.getParentClass(clazz);
+            if (parentClazz.name === '') {
+                return [];
+            }
+            return this.getConstructorParameters(parentClazz);
+        }
+        return ParameterParser.parse(code, CONSTRUCTOR_NAME);
+    }
+    static getFunctionParameters(funktion) {
+        const code = funktion.toString();
+        return ParameterParser.parse(code, FUNCTION_NAME);
+    }
+}

package/dist/core/reflection/models/ReflectionField.d.ts

@@ -0,0 +1,8 @@
+export default class ReflectionField {
+    #private;
+    constructor(name: string, canGet: boolean, canSet: boolean);
+    get name(): string;
+    get canGet(): boolean;
+    get canSet(): boolean;
+    get canGetAndSet(): boolean;
+}

package/dist/core/reflection/models/ReflectionField.js

@@ -0,0 +1,14 @@
+export default class ReflectionField {
+    #name;
+    #canGet;
+    #canSet;
+    constructor(name, canGet, canSet) {
+        this.#name = name;
+        this.#canGet = canGet;
+        this.#canSet = canSet;
+    }
+    get name() { return this.#name; }
+    get canGet() { return this.#canGet; }
+    get canSet() { return this.#canSet; }
+    get canGetAndSet() { return this.#canGet && this.#canSet; }
+}

package/dist/core/reflection/models/ReflectionParameter.d.ts

@@ -0,0 +1,7 @@
+export default class ReflectionParameter {
+    #private;
+    constructor(name: string, defaultValue?: string);
+    get name(): string;
+    get defaultValue(): string | undefined;
+    get isOptional(): boolean;
+}

package/dist/core/reflection/models/ReflectionParameter.js

@@ -0,0 +1,11 @@
+export default class ReflectionParameter {
+    #name;
+    #defaultValue;
+    constructor(name, defaultValue) {
+        this.#name = name;
+        this.#defaultValue = defaultValue;
+    }
+    get name() { return this.#name; }
+    get defaultValue() { return this.#defaultValue; }
+    get isOptional() { return this.#defaultValue !== undefined; }
+}

package/dist/core/types/Component.d.ts

@@ -0,0 +1,5 @@
+declare type Component = {
+    name: string;
+    source?: string;
+};
+export default Component;

package/dist/core/types/Component.js

@@ -0,0 +1 @@
+export {};