jitar 0.3.9 → 0.4.1

package/dist/runtime/Remote.js

@@ -1,102 +0,0 @@
-import File from './models/File.js';
-import ValueSerializer from './serialization/ValueSerializer.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-export default class Remote {
-    #url;
-    #useSerializer;
-    constructor(url, useSerializer) {
-        this.#url = url;
-        this.#useSerializer = useSerializer;
-    }
-    async registerClient(segmentFiles) {
-        const url = `${this.#url}/modules`;
-        const options = {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(segmentFiles)
-        };
-        const response = await this.#callRemote(url, options, 200);
-        const clientId = await response.text();
-        return clientId;
-    }
-    async loadFile(filename) {
-        const url = `${this.#url}/${filename}`;
-        const options = { method: 'GET' };
-        const response = await this.#callRemote(url, options, 200);
-        const type = response.headers.get('Content-Type') || 'application/octet-stream';
-        const content = await response.text();
-        return new File(filename, type, content);
-    }
-    async importFile(filename) {
-        const url = `${this.#url}/${filename}`;
-        return ModuleLoader.load(url);
-    }
-    async isHealthy() {
-        const url = `${this.#url}/health/status`;
-        const options = { method: 'GET' };
-        const response = await this.#callRemote(url, options, 200);
-        const healthy = await response.text();
-        return Boolean(healthy);
-    }
-    async getHealth() {
-        const url = `${this.#url}/health`;
-        const options = { method: 'GET' };
-        const response = await this.#callRemote(url, options, 200);
-        const health = await response.json();
-        return new Map(Object.entries(health));
-    }
-    async addNode(node) {
-        const url = `${this.#url}/nodes`;
-        const body = {
-            url: node.url,
-            procedureNames: node.getProcedureNames()
-        };
-        const options = {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body)
-        };
-        await this.#callRemote(url, options, 201);
-    }
-    async run(fqn, version, args, headers) {
-        headers.set('content-type', 'application/json');
-        const versionString = version.toString();
-        const argsObject = Object.fromEntries(args);
-        const headersObject = Object.fromEntries(headers);
-        const url = `${this.#url}/rpc/${fqn}?version=${versionString}&serialize=true`;
-        const options = {
-            method: 'POST',
-            headers: headersObject,
-            body: this.#createRequestBody(argsObject, this.#useSerializer)
-        };
-        const response = await this.#callRemote(url, options, 200);
-        return this.#createResponseResult(response, this.#useSerializer);
-    }
-    async #callRemote(url, options, expectedStatus) {
-        const response = await fetch(url, options);
-        if (response.status !== expectedStatus) {
-            const error = await this.#createResponseResult(response, true);
-            throw error;
-        }
-        return response;
-    }
-    #createRequestBody(body, serialize) {
-        const data = serialize
-            ? ValueSerializer.serialize(body)
-            : body;
-        return JSON.stringify(data);
-    }
-    async #createResponseResult(response, serialize) {
-        const result = await this.#getResponseResult(response);
-        return serialize
-            ? ValueSerializer.deserialize(result)
-            : result;
-    }
-    async #getResponseResult(response) {
-        const contentType = response.headers.get('Content-Type');
-        if (contentType !== null && contentType.includes('json')) {
-            return response.json();
-        }
-        return response.text();
-    }
-}

package/dist/runtime/RemoteGateway.d.ts

@@ -1,11 +0,0 @@
-import Version from '../core/Version.js';
-import Gateway from './Gateway.js';
-import Node from './Node.js';
-export default class RemoteGateway extends Gateway {
-    #private;
-    constructor(url: string);
-    getProcedureNames(): string[];
-    hasProcedure(name: string): boolean;
-    addNode(node: Node): Promise<void>;
-    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
-}

package/dist/runtime/RemoteGateway.js

@@ -1,22 +0,0 @@
-import NotImplemented from '../core/errors/NotImplemented.js';
-import Gateway from './Gateway.js';
-import Remote from './Remote.js';
-export default class RemoteGateway extends Gateway {
-    #remote;
-    constructor(url) {
-        super(url);
-        this.#remote = new Remote(url, true);
-    }
-    getProcedureNames() {
-        throw new NotImplemented();
-    }
-    hasProcedure(name) {
-        throw new NotImplemented();
-    }
-    async addNode(node) {
-        return this.#remote.addNode(node);
-    }
-    async run(fqn, version, args, headers) {
-        return this.#remote.run(fqn, version, args, headers);
-    }
-}

package/dist/runtime/RemoteNode.d.ts

@@ -1,12 +0,0 @@
-import Version from '../core/Version.js';
-import Node from './Node.js';
-export default class RemoteNode extends Node {
-    #private;
-    constructor(url: string, procedureNames: string[]);
-    getProcedureNames(): string[];
-    registerProcedures(procedureNames: string[]): void;
-    hasProcedure(name: string): boolean;
-    isHealthy(): Promise<boolean>;
-    getHealth(): Promise<Map<string, boolean>>;
-    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
-}

package/dist/runtime/RemoteNode.js

@@ -1,29 +0,0 @@
-import Node from './Node.js';
-import Remote from './Remote.js';
-export default class RemoteNode extends Node {
-    #remote;
-    #procedureNames = new Set();
-    constructor(url, procedureNames) {
-        super(url);
-        this.#remote = new Remote(url, false);
-        this.registerProcedures(procedureNames);
-    }
-    getProcedureNames() {
-        return [...this.#procedureNames.values()];
-    }
-    registerProcedures(procedureNames) {
-        procedureNames.forEach(procedureName => this.#procedureNames.add(procedureName));
-    }
-    hasProcedure(name) {
-        return this.#procedureNames.has(name);
-    }
-    async isHealthy() {
-        return this.#remote.isHealthy();
-    }
-    async getHealth() {
-        return this.#remote.getHealth();
-    }
-    async run(fqn, version, args, headers) {
-        return this.#remote.run(fqn, version, args, headers);
-    }
-}

package/dist/runtime/RemoteRepository.d.ts

@@ -1,14 +0,0 @@
-import Module from '../core/types/Module.js';
-import File from './models/File.js';
-import Repository from './Repository.js';
-import Runtime from './Runtime.js';
-export default class RemoteRepository extends Repository {
-    #private;
-    constructor(url: string);
-    registerClient(segmentFiles: string[]): Promise<string>;
-    setRuntime(runtime: Runtime): Promise<void>;
-    loadAsset(filename: string): Promise<File>;
-    getModuleLocation(clientId: string): Promise<string>;
-    loadModule(clientId: string, filename: string): Promise<File>;
-    importModule(clientId: string, filename: string): Promise<Module>;
-}

package/dist/runtime/RemoteRepository.js

@@ -1,34 +0,0 @@
-import InvalidJitarHooks from './errors/InvalidJitarHooks.js';
-import Remote from './Remote.js';
-import Repository from './Repository.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-export default class RemoteRepository extends Repository {
-    #remote;
-    constructor(url) {
-        super(url);
-        this.#remote = new Remote(url, true);
-    }
-    async registerClient(segmentFiles) {
-        return this.#remote.registerClient(segmentFiles);
-    }
-    async setRuntime(runtime) {
-        const jitar = await this.#remote.importFile('jitar/hooks.js');
-        if (jitar?.setRuntime === undefined || jitar?.setDependencyLoader === undefined) {
-            throw new InvalidJitarHooks();
-        }
-        jitar.setRuntime(runtime);
-        jitar.setDependencyLoader(ModuleLoader.import);
-    }
-    async loadAsset(filename) {
-        return this.#remote.loadFile(filename);
-    }
-    async getModuleLocation(clientId) {
-        return `${this.url}/modules/${clientId}`;
-    }
-    async loadModule(clientId, filename) {
-        return this.#remote.loadFile(`modules/${clientId}/${filename}`);
-    }
-    async importModule(clientId, filename) {
-        return this.#remote.importFile(`modules/${clientId}/${filename}`);
-    }
-}

package/dist/runtime/Repository.d.ts

@@ -1,11 +0,0 @@
-import Module from '../core/types/Module.js';
-import File from './models/File.js';
-import Runtime from './Runtime.js';
-export default abstract class Repository extends Runtime {
-    abstract registerClient(segmentFiles: string[]): Promise<string>;
-    abstract setRuntime(runtime: Runtime): Promise<void>;
-    abstract loadAsset(filename: string): Promise<File>;
-    abstract getModuleLocation(clientId: string): Promise<string>;
-    abstract loadModule(clientId: string, filename: string): Promise<File>;
-    abstract importModule(clientId: string, filename: string): Promise<Module>;
-}

package/dist/runtime/Repository.js

@@ -1,3 +0,0 @@
-import Runtime from './Runtime.js';
-export default class Repository extends Runtime {
-}

package/dist/runtime/Runtime.d.ts

@@ -1,9 +0,0 @@
-import HealthCheck from './interfaces/HealthCheck.js';
-export default abstract class Runtime {
-    #private;
-    constructor(url?: string);
-    get url(): string | undefined;
-    addHealthCheck(name: string, healthCheck: HealthCheck): void;
-    isHealthy(): Promise<boolean>;
-    getHealth(): Promise<Map<string, boolean>>;
-}

package/dist/runtime/Runtime.js

@@ -1,27 +0,0 @@
-export default class Runtime {
-    #url;
-    #healthChecks = new Map();
-    constructor(url) {
-        this.#url = url;
-    }
-    get url() { return this.#url; }
-    addHealthCheck(name, healthCheck) {
-        this.#healthChecks.set(name, healthCheck);
-    }
-    async isHealthy() {
-        for (const healthCheck of this.#healthChecks.values()) {
-            if (await healthCheck.isHealthy() === false) {
-                return false;
-            }
-        }
-        return true;
-    }
-    async getHealth() {
-        const health = new Map();
-        for (const [name, healthCheck] of this.#healthChecks) {
-            const healthy = await healthCheck.isHealthy();
-            health.set(name, healthy);
-        }
-        return health;
-    }
-}

package/dist/runtime/caching/CacheBuilder.d.ts

@@ -1,6 +0,0 @@
-import FileManager from '../interfaces/FileManager.js';
-export default class CacheBuilder {
-    #private;
-    constructor(sourceManager: FileManager, cacheManager: FileManager);
-    build(segmentFiles: string[], moduleFiles: string[]): Promise<void>;
-}

package/dist/runtime/caching/CacheBuilder.js

@@ -1,246 +0,0 @@
-import * as AccessLevel from '../../core/definitions/AccessLevel.js';
-import Version from '../../core/Version.js';
-import ModuleAnalyser from '../utils/ModuleAnalyser.js';
-import SourceAppender from './SourceAppender.js';
-import ImportRewriter from './ImportRewriter.js';
-import RemoteBuilder from './RemoteBuilder.js';
-import ApplicationModule from './models/ApplicationModule.js';
-import Procedure from './models/Procedure.js';
-import Segment from './models/Segment.js';
-import SegmentModule from './models/SegmentModule.js';
-import Implementation from './models/Implementation.js';
-import SegmentFileNotLoaded from './errors/SegmentFileNotLoaded.js';
-import SegmentModuleNotLoaded from './errors/SegmentModuleNotLoaded.js';
-import MissingModuleExport from './errors/MissingModuleExport.js';
-import InvalidSegmentFilename from './errors/InvalidSegmentFilename.js';
-import { Reflector } from 'jitar-reflection';
-const IGNORED_SOURCE_FILES = ['.min.js'];
-const DEFAULT_ACCESS_LEVEL = AccessLevel.PRIVATE;
-const DEFAULT_VERSION_NUMBER = Version.DEFAULT.toString();
-const reflector = new Reflector();
-export default class CacheBuilder {
-    #sourceManager;
-    #cacheManager;
-    constructor(sourceManager, cacheManager) {
-        this.#sourceManager = sourceManager;
-        this.#cacheManager = cacheManager;
-    }
-    async build(segmentFiles, moduleFiles) {
-        const applicationFiles = this.#filterApplicationFiles(moduleFiles);
-        const segments = await this.#createSegments(segmentFiles);
-        const applicationModules = await this.#createApplicationModules(applicationFiles);
-        await this.#buildSegmentCache(segments);
-        await this.#buildApplicationCache(applicationModules);
-    }
-    #filterApplicationFiles(fileNames) {
-        return fileNames.filter(filename => this.#mustIgnoreFile(filename) === false);
-    }
-    #mustIgnoreFile(filename) {
-        return IGNORED_SOURCE_FILES.some((ignored) => filename.endsWith(ignored));
-    }
-    async #createSegments(filenames) {
-        const promises = filenames.map(async (filename) => this.#createSegment(filename));
-        return Promise.all(promises).then(segments => segments);
-    }
-    async #createSegment(filename) {
-        const definition = await this.#loadSegmentDefinition(filename);
-        const modules = await this.#createSegmentModules(definition);
-        const procedures = this.#createSegmentProcedures(modules);
-        return new Segment(filename, modules, procedures);
-    }
-    async #loadSegmentDefinition(filename) {
-        try {
-            const content = await this.#sourceManager.getContent(filename);
-            return JSON.parse(content.toString());
-        }
-        catch (error) {
-            throw new SegmentFileNotLoaded(filename);
-        }
-    }
-    async #createSegmentModules(definition) {
-        const modules = [];
-        for (const [moduleFilename, moduleImports] of Object.entries(definition)) {
-            const absoluteLocation = this.#sourceManager.getAbsoluteLocation(moduleFilename);
-            const module = await this.#createSegmentModule(absoluteLocation, moduleImports);
-            modules.push(module);
-        }
-        return modules;
-    }
-    async #createSegmentModule(absoluteLocation, imports) {
-        const exports = await this.#loadSegmentModule(absoluteLocation);
-        const implementations = await this.#createSegmentModuleImplementations(absoluteLocation, exports, imports);
-        return new SegmentModule(absoluteLocation, exports, implementations);
-    }
-    async #loadSegmentModule(absoluteLocation) {
-        const module = await this.#loadModule(absoluteLocation);
-        if (module === undefined) {
-            throw new SegmentModuleNotLoaded(absoluteLocation);
-        }
-        return module;
-    }
-    async #createSegmentModuleImplementations(absoluteLocation, exports, imports) {
-        const moduleName = this.#extractModuleName(absoluteLocation);
-        const implementations = new Map();
-        for (const [importKey, properties] of Object.entries(imports)) {
-            const executable = exports.getExported(importKey);
-            if (executable === undefined) {
-                throw new MissingModuleExport(moduleName, importKey);
-            }
-            const procedureName = properties.as ?? executable.name;
-            const access = properties.access ?? DEFAULT_ACCESS_LEVEL;
-            const version = properties.version ?? DEFAULT_VERSION_NUMBER;
-            const implementation = new Implementation(moduleName, procedureName, access, version, executable);
-            implementations.set(importKey, implementation);
-        }
-        return implementations;
-    }
-    #createSegmentProcedures(modules) {
-        const procedures = new Map();
-        for (const module of modules) {
-            for (const implementation of module.implementations.values()) {
-                let procedure = procedures.get(implementation.fqn);
-                if (procedure === undefined) {
-                    procedure = new Procedure(implementation.module, implementation.name);
-                    procedures.set(implementation.fqn, procedure);
-                }
-                procedure.addImplementation(implementation);
-            }
-        }
-        return procedures;
-    }
-    #extractModuleName(absoluteLocation) {
-        const relativeLocation = this.#sourceManager.getRelativeLocation(absoluteLocation);
-        const moduleParts = relativeLocation.split('/');
-        moduleParts.pop();
-        return moduleParts.join('/');
-    }
-    async #createApplicationModules(filenames) {
-        const promises = filenames.map(async (filename) => this.#createApplicationModule(filename));
-        return Promise.all(promises).then(results => results);
-    }
-    async #createApplicationModule(filename) {
-        const module = await this.#loadModule(filename);
-        const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
-        if (module === undefined) {
-            return new ApplicationModule(relativeLocation, new Map(), new Map());
-        }
-        const classes = ModuleAnalyser.filterClasses(module);
-        const functions = ModuleAnalyser.filterFunctions(module);
-        return new ApplicationModule(relativeLocation, classes, functions);
-    }
-    async #loadModule(filename) {
-        const code = await this.#sourceManager.getContent(filename);
-        return reflector.parse(code.toString());
-    }
-    async #buildSegmentCache(segments) {
-        const promises = segments.map(async (segment) => this.#buildSegmentModuleCache(segment));
-        return Promise.all(promises);
-    }
-    async #buildSegmentModuleCache(segment) {
-        await this.#buildSegmentCacheForRepository(segment);
-        await this.#buildSegmentCacheForNode(segment);
-    }
-    async #buildSegmentCacheForRepository(segment) {
-        return this.#buildSegmentDefinitionForRepository(segment);
-    }
-    async #buildSegmentDefinitionForRepository(segment) {
-        const code = this.#createSegmentRepositoryCode(segment);
-        const filename = this.#createSegmentRepositoryFilename(segment);
-        return this.#cacheManager.store(filename, code);
-    }
-    #createSegmentRepositoryCode(segment) {
-        const filenames = segment.getFilenames();
-        const relativeLocations = filenames.map(filename => this.#sourceManager.getRelativeLocation(filename));
-        return `export const files = [\n\t"${[...relativeLocations].join('",\n\t"')}"\n];`;
-    }
-    #createSegmentRepositoryFilename(segment) {
-        const filename = this.#extractSegmentFilename(segment);
-        return filename.replace('.json', '.repository.js');
-    }
-    async #buildSegmentCacheForNode(segment) {
-        await this.#buildSegmentDefinitionForNode(segment);
-        await this.#buildSegmentModulesForNode(segment);
-    }
-    async #buildSegmentDefinitionForNode(segment) {
-        const code = this.#createSegmentNodeCode(segment);
-        const filename = this.#createSegmentNodeFilename(segment);
-        return this.#cacheManager.store(filename, code);
-    }
-    #createSegmentNodeCode(segment) {
-        const importCode = this.#createSegmentImportCode(segment);
-        const modelCode = this.#createSegmentModelCode(segment);
-        return `${importCode}\n\n${modelCode}`;
-    }
-    #createSegmentImportCode(segment) {
-        const codes = [];
-        for (const module of segment.modules) {
-            const relativeLocation = this.#sourceManager.getRelativeLocation(module.filename);
-            const imports = [];
-            for (const [importKey, implementation] of module.implementations) {
-                imports.push(`${importKey} as $${implementation.id}`);
-            }
-            codes.push(`import { ${imports.join(',')} } from "./${relativeLocation}";`);
-        }
-        return codes.join('\n');
-    }
-    #createSegmentModelCode(segment) {
-        const procedureCode = [];
-        for (const procedure of segment.procedures.values()) {
-            const implementationCode = [];
-            for (const implementation of procedure.implementations) {
-                implementationCode.push(`{ access: "${implementation.access}", version: "${implementation.version}", executable: $${implementation.id} }`);
-            }
-            procedureCode.push(`{ module: "${procedure.module}", name: "${procedure.name}", implementations: [\n\t\t${implementationCode.join(',\n\t\t')}\n\t]}`);
-        }
-        return `export const procedures = [\n\t${procedureCode.join(',\n\t')}\n];`;
-    }
-    async #buildSegmentModulesForNode(segment) {
-        for (const module of segment.modules) {
-            const filename = module.filename;
-            const absoluteLocation = this.#sourceManager.getAbsoluteLocation(filename);
-            const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
-            const file = await this.#sourceManager.load(absoluteLocation);
-            const code = file.content.toString();
-            await this.#buildSegmentModuleForLocal(code, relativeLocation);
-            await this.#buildSegmentModuleForRemote(module, relativeLocation);
-        }
-    }
-    async #buildSegmentModuleForLocal(code, location) {
-        const importedCode = ImportRewriter.rewrite(code);
-        const nodeLocation = location.replace('.js', '.local.js');
-        return this.#cacheManager.store(nodeLocation, importedCode);
-    }
-    async #buildSegmentModuleForRemote(module, location) {
-        const remoteCode = RemoteBuilder.build(module);
-        const remoteLocation = location.replace('.js', '.remote.js');
-        return this.#cacheManager.store(remoteLocation, remoteCode);
-    }
-    #createSegmentNodeFilename(segment) {
-        const filename = this.#extractSegmentFilename(segment);
-        return filename.replace('.json', '.local.js');
-    }
-    #extractSegmentFilename(segment) {
-        const filename = segment.filename.split('/').pop();
-        if (filename === undefined) {
-            throw new InvalidSegmentFilename(segment.filename);
-        }
-        return filename;
-    }
-    async #buildApplicationCache(applicationModules) {
-        const promises = applicationModules.map(async (module) => this.#buildApplicationModuleCache(module));
-        return Promise.all(promises);
-    }
-    async #buildApplicationModuleCache(module) {
-        return this.#buildApplicationShareables(module);
-    }
-    async #buildApplicationShareables(module) {
-        if (module.hasClasses() === false) {
-            return;
-        }
-        const filename = module.filename;
-        const file = await this.#sourceManager.load(filename);
-        const code = file.content.toString();
-        const sourcedCode = SourceAppender.append(module, code, filename);
-        return this.#cacheManager.store(filename, sourcedCode);
-    }
-}

package/dist/runtime/caching/ImportRewriter.d.ts

@@ -1,4 +0,0 @@
-export default class ImportRewriter {
-    #private;
-    static rewrite(content: string): string;
-}

package/dist/runtime/caching/ImportRewriter.js

@@ -1,58 +0,0 @@
-import { Reflector } from 'jitar-reflection';
-import * as Keywords from './definitions/Keywords.js';
-const IMPORT_PATTERN = /import(?:["'\s]*([\w*{}\n, ]+)from\s*)?["'\s]*([@\w/_-]+)["'\s].*/g;
-const NON_SYSTEM_INDICATORS = ['.', '/', 'http:', 'https:'];
-const reflector = new Reflector();
-export default class ImportRewriter {
-    static rewrite(content) {
-        const replacer = (statement) => this.#replaceImport(statement);
-        const newContent = content.replaceAll(IMPORT_PATTERN, replacer);
-        return newContent !== content
-            ? this.#insertGetDependency(newContent)
-            : newContent;
-    }
-    static #replaceImport(statement) {
-        const dependency = reflector.parseImport(statement);
-        return this.#isSystemDependency(dependency)
-            ? this.#rewriteImport(dependency)
-            : statement;
-    }
-    static #isSystemDependency(dependency) {
-        return NON_SYSTEM_INDICATORS.some(indicator => dependency.from.startsWith(indicator, 1)) === false;
-    }
-    static #isJitarDependency(dependency) {
-        return dependency.from.includes(Keywords.JITAR);
-    }
-    static #rewriteImport(dependency) {
-        if (dependency.members.length === 0) {
-            return `await getDependency(${dependency.from});`;
-        }
-        const members = this.#rewriteImportMembers(dependency);
-        if (this.#isJitarDependency(dependency)) {
-            return `import ${members} from "/jitar/hooks.js";`;
-        }
-        return `const ${members} = await getDependency(${dependency.from});`;
-    }
-    static #rewriteImportMembers(dependency) {
-        if (this.#mustUseAs(dependency)) {
-            return dependency.members[0].as;
-        }
-        const members = dependency.members.map(member => member.name !== member.as ? `${member.name}: ${member.as}` : member.name);
-        return `{ ${members.join(', ')} }`;
-    }
-    static #mustUseAs(dependency) {
-        return this.#doesImportAll(dependency)
-            || this.#doesImportDefault(dependency);
-    }
-    static #doesImportAll(dependency) {
-        return dependency.members.length === 1
-            && dependency.members[0].name === '*';
-    }
-    static #doesImportDefault(dependency) {
-        return dependency.members.length === 1
-            && dependency.members[0].name === 'default';
-    }
-    static #insertGetDependency(module) {
-        return `import { getDependency } from "/jitar/hooks.js";\n${module}`;
-    }
-}

package/dist/runtime/caching/RemoteBuilder.d.ts

@@ -1,5 +0,0 @@
-import SegmentModule from './models/SegmentModule.js';
-export default class RemoteBuilder {
-    #private;
-    static build(module: SegmentModule): string;
-}

package/dist/runtime/caching/RemoteBuilder.js

@@ -1,31 +0,0 @@
-import * as AccessLevel from '../../core/definitions/AccessLevel.js';
-import * as Keywords from './definitions/Keywords.js';
-import { ReflectionField } from 'jitar-reflection';
-export default class RemoteBuilder {
-    static build(module) {
-        let code = this.#createRemoteImports();
-        for (const [importKey, implementation] of module.implementations) {
-            if (implementation.access !== AccessLevel.PUBLIC) {
-                continue;
-            }
-            const asDefault = importKey === Keywords.DEFAULT;
-            code += this.#createRemoteCode(implementation, asDefault);
-        }
-        return code;
-    }
-    static #createRemoteImports() {
-        return `import { runProcedure } from "/jitar/hooks.js";\n`;
-    }
-    static #createRemoteCode(implementation, asDefault) {
-        const parameters = implementation.executable.parameters.filter(parameter => parameter instanceof ReflectionField);
-        const parameterNames = parameters.map(parameter => parameter.name);
-        const procedureName = implementation.executable.name;
-        const procedureFqn = implementation.fqn;
-        const procedureVersion = implementation.version;
-        const procedueParameters = parameterNames.join(', ');
-        const procedureArguments = parameterNames.map(name => `'${name}': ${name}`).join(', ');
-        const functionName = `\nexport ${asDefault ? `${Keywords.DEFAULT} ` : ''}async function ${procedureName}(${procedueParameters})`;
-        const functionBody = `return runProcedure('${procedureFqn}', '${procedureVersion}', { ${procedureArguments} }, this)`;
-        return `${functionName} {\n\t${functionBody}\n}\n`;
-    }
-}

package/dist/runtime/caching/SourceAppender.d.ts

@@ -1,5 +0,0 @@
-import ApplicationModule from './models/ApplicationModule.js';
-export default class SourceAppender {
-    #private;
-    static append(module: ApplicationModule, code: string, filename: string): string;
-}