ghostos 0.1.15 → 0.1.16

package/lib/api/parser/elements/schema/directus.d.ts

@@ -0,0 +1,72 @@
+export default schema;
+declare namespace schema {
+    export let $schema: string;
+    export let $id: string;
+    export let title: string;
+    export let description: string;
+    export let type: string;
+    export namespace properties {
+        namespace nodeuuid {
+            let description_1: string;
+            export { description_1 as description };
+            let type_1: string;
+            export { type_1 as type };
+        }
+        namespace status {
+            let description_2: string;
+            export { description_2 as description };
+            let type_2: string;
+            export { type_2 as type };
+        }
+        namespace config {
+            let type_3: string;
+            export { type_3 as type };
+            export namespace properties_1 {
+                namespace KEY {
+                    let type_4: string;
+                    export { type_4 as type };
+                }
+                namespace SECRET {
+                    let type_5: string;
+                    export { type_5 as type };
+                }
+                namespace ADMIN_EMAIL {
+                    let type_6: string;
+                    export { type_6 as type };
+                }
+                namespace ADMIN_PASSWORD {
+                    let type_7: string;
+                    export { type_7 as type };
+                }
+                namespace DB_CLIENT {
+                    let type_8: string;
+                    export { type_8 as type };
+                }
+                namespace DB_HOST {
+                    let type_9: string;
+                    export { type_9 as type };
+                }
+                namespace DB_PORT {
+                    let type_10: string;
+                    export { type_10 as type };
+                }
+                namespace DB_DATABASE {
+                    let type_11: string;
+                    export { type_11 as type };
+                }
+                namespace DB_USER {
+                    let type_12: string;
+                    export { type_12 as type };
+                }
+                namespace DB_PASSWORD {
+                    let type_13: string;
+                    export { type_13 as type };
+                }
+            }
+            export { properties_1 as properties };
+            export let required: string[];
+        }
+    }
+    let required_1: string[];
+    export { required_1 as required };
+}

package/lib/api/parser/elements/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { directus_schema };
+import directus_schema from "./directus.js";

package/lib/api/parser/eta.d.ts

@@ -0,0 +1,55 @@
+export function etaReduceLambdaGraphs({ refnode, nodelambda, contextuallambda, etaTree, addnodelut, metadata, }?: {
+    addnodelut?: boolean | undefined;
+    metadata?: {} | undefined;
+}): Promise<{
+    _nodelut: {};
+} | {
+    _nodelut?: undefined;
+}>;
+export const etaReduceDataflowComponent: any;
+export function runtimeEtaTree(_mode: any, _host_domain: any, _host_appid: any, _domain: any, _appid: any, _leafgraph: any, _graphcomponents: any, _leafio: any, _leaflakeio: any, _mnemosyne: any, _hostEtaTree?: undefined): {
+    sessionid: any;
+    appmode: any;
+    hostdomain: any;
+    hostappid: any;
+    domain: any;
+    appid: any;
+    leafgraph: undefined;
+    graphcomponents: undefined;
+    rootgraphstate: undefined;
+    leafio: undefined;
+    leaflakeio: undefined;
+    mnemosyne: undefined;
+    hostEtaTree: undefined;
+    leafnodemethods: {};
+    lookupRuntimeLambdaLUT: (graphdomain: any, graphappid: any, refnode: any, nodelambda: any, contextuallambda: any, isnodeonly?: boolean) => Promise<{
+        _default: (inputArr$: any) => undefined;
+    } | {
+        _nodelut: {};
+    } | {
+        _nodelut?: undefined;
+    }>;
+    lookupLEAFNodeMethods: (nodeuuid: any, _refnodedata?: undefined) => Promise<any>;
+    etaReduceLEAFNode: ({ nodeuuid, contextuallambda }?: {}) => Promise<{
+        _default: (inputArr$: any) => undefined;
+    }>;
+    loadElementJsEsmModule: (moduleUrl: any) => Promise<any>;
+    initTree: (_leafgraph: any, _graphcomponents: any, _leafio: any, _leaflakeio: any, _mnemosyne: any) => ({ nodeuuid, contextuallambda }?: {}) => Promise<{
+        _default: (inputArr$: any) => undefined;
+    }>;
+};
+export function rxTimeoutStream(prom: any, time: any, codebase: any, exception: any, metadata: any): import("rxjs").Observable<any>;
+export function doChronosSynchronize(_stream$objArr: any, _gates?: {
+    time: number;
+    count: number;
+}, _nodeflowinterface?: undefined, rt_context?: {}): {
+    ctrl: any;
+    data: import("rxjs").Observable<any>;
+};
+export function doChronosAsynchronize(_stream$objArr: any, _gates?: {
+    time: number;
+    count: number;
+}, rt_context?: {}): {
+    ctrl: import("rxjs").Observable<unknown>;
+    data: import("rxjs").Observable<any>;
+};

package/lib/api/parser/eta.spec.d.ts

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

package/lib/api/parser/etatreeforest.d.ts

@@ -0,0 +1,37 @@
+export function etaTreeForest(refEtaTree: any): {
+    initEtaTreeForest: () => void;
+    getEtaTree: (graphdomain: any, graphappid: any) => Promise<any>;
+    setEtaTree: (graphdomain: any, graphappid: any, etaTree: any, parentname: any) => void;
+    removeEtaBush: (graphdomain: any, graphappid: any) => void;
+    parseGraphEtaTree: (graphdomain: any, graphappid: any) => Promise<{
+        sessionid: any;
+        appmode: any;
+        hostdomain: any;
+        hostappid: any;
+        domain: any;
+        appid: any;
+        leafgraph: undefined;
+        graphcomponents: undefined;
+        rootgraphstate: undefined;
+        leafio: undefined;
+        leaflakeio: undefined;
+        mnemosyne: undefined;
+        hostEtaTree: undefined;
+        leafnodemethods: {};
+        lookupRuntimeLambdaLUT: (graphdomain: any, graphappid: any, refnode: any, nodelambda: any, contextuallambda: any, isnodeonly?: boolean) => Promise<{
+            _default: (inputArr$: any) => undefined;
+        } | {
+            _nodelut: {};
+        } | {
+            _nodelut?: undefined;
+        }>;
+        lookupLEAFNodeMethods: (nodeuuid: any, _refnodedata?: undefined) => Promise<any>;
+        etaReduceLEAFNode: ({ nodeuuid, contextuallambda }?: {}) => Promise<{
+            _default: (inputArr$: any) => undefined;
+        }>;
+        loadElementJsEsmModule: (moduleUrl: any) => Promise<any>;
+        initTree: (_leafgraph: any, _graphcomponents: any, _leafio: any, _leaflakeio: any, _mnemosyne: any) => ({ nodeuuid, contextuallambda }?: {}) => Promise<{
+            _default: (inputArr$: any) => undefined;
+        }>;
+    }>;
+};

package/lib/api/parser/leaf.d.ts

@@ -0,0 +1,56 @@
+export const _version: string;
+export function reconstructLEAFGraph(nodes: any, masterSubsDirectory: any): {
+    graph: {
+        lambda: Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;
+        dataflow: Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;
+    };
+    thespade: {
+        uuid: undefined;
+    };
+    edges: {
+        data: {
+            sources: Set<any>;
+            targets: Set<any>;
+        };
+        lambda: {
+            sources: Set<any>;
+            targets: Set<any>;
+            sourcelut: {};
+        };
+        anchor: {
+            targets: Set<any>;
+        };
+    };
+};
+export function analyzeLEAFGraph(leafgraph: any): {
+    spelldefs: {};
+    leafconfig: undefined;
+    components: {
+        nodegroups: {
+            runtime: any[];
+            lambda: any[];
+            anchored: any[];
+        };
+        lut: {};
+    };
+};
+export function executeLEAFLogic(leaflogic: any, data_input: any, runtimeconfig?: {}, refnode?: undefined, ctrl_input?: undefined): Promise<any>;
+export function subscribeToLEAFLogic(leaflogic: any, input: any, runtimeconfig: any, stopper$: any): Promise<void>;
+export function executeLEAFLogicInSync(leaflogic: any, input$: any, output$inst: any, ctrlinput$: any, runtimeconfig: any, flowname?: undefined): any;
+export function driveDataflowByCtrlflow(inflow_ctrl$obj: any, data_inflow$objArr: any, meta_ctrl_in$: any, context?: {}, transformation?: {
+    leaflogic: undefined;
+    datalogic: {
+        pre: undefined;
+        post: undefined;
+    };
+}): {
+    _stream: import("rxjs").Observable<any>;
+    _control: {
+        _stream: any;
+        _config: any;
+    };
+};
+export function leafTraceFlow(_prevtraces: any, _curtrace: any, consolelog?: boolean): any;
+export function parseAddressableGraph(addrstr: any, _etaTree: any, _refnode: any): Promise<{} | undefined>;
+export function timeoutPromise(prom: any, time: any, codebase: any, exception: any, metadata: any): Promise<any>;
+import Graph from "graphology";

package/lib/api/parser/leafgraph-testbed.browser.test.d.ts

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

package/lib/api/parser/leafgraph-tests.browser.test.d.ts

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

package/lib/api/parser/leaflisp/plispdist/index.d.ts

@@ -0,0 +1,210 @@
+export class Interpreter {
+    constructor(options: any, literals: any);
+    globals: Environment;
+    currentEnv: Environment;
+    lastLiteral: any;
+    lastPrint: any;
+    execLiteral: (literal: any, env: any) => any;
+    options: any;
+    interpret(program: any): any;
+    evalFn(fn: any, args: any): any;
+    execList(literal: any, env: any): any;
+    getGlobalNames(): string[];
+    clearEnv(): void;
+}
+export class Parser {
+    constructor(scanner: any, literals?: {
+        Bool: {
+            parser: (x: any) => boolean;
+            factory: BooleanConstructor;
+        };
+        Nothing: {
+            parser: (x: any) => boolean;
+            factory: () => never;
+        };
+        Int: {
+            parser: (x: any) => number;
+            factory: NumberConstructor;
+        };
+        Float: {
+            parser: typeof parseFloat;
+            factory: NumberConstructor;
+        };
+        String: {
+            parser: (str: any) => any;
+            factory: StringConstructor;
+        };
+        FractionNumber: {
+            parser: (str: any) => any;
+            factory: () => never;
+        };
+        Vector: {
+            parser: () => never;
+            factory: () => never;
+        };
+        HashMap: {
+            parser: () => never;
+            factory: () => never;
+        };
+    });
+    scanner: any;
+    literals: {
+        Bool: {
+            parser: (x: any) => boolean;
+            factory: BooleanConstructor;
+        };
+        Nothing: {
+            parser: (x: any) => boolean;
+            factory: () => never;
+        };
+        Int: {
+            parser: (x: any) => number;
+            factory: NumberConstructor;
+        };
+        Float: {
+            parser: typeof parseFloat;
+            factory: NumberConstructor;
+        };
+        String: {
+            parser: (str: any) => any;
+            factory: StringConstructor;
+        };
+        FractionNumber: {
+            parser: (str: any) => any;
+            factory: () => never;
+        };
+        Vector: {
+            parser: () => never;
+            factory: () => never;
+        };
+        HashMap: {
+            parser: () => never;
+            factory: () => never;
+        };
+    };
+    hadError: boolean;
+    panicMode: boolean;
+    current: Token;
+    _program: any[];
+    _errors: any[];
+    dispatchMode: boolean;
+    missingParser: (name: any) => void;
+    parse(): {
+        hasError: boolean;
+        program: any[];
+        errors: any[];
+    };
+    get program(): any[];
+    get errors(): any[];
+    advance(): void;
+    consume(type: any, message: any): void;
+    errorAtCurrent(message: any): void;
+    errorAt(token: any, message: any): void;
+    isEnd(): boolean;
+    peek(): Token;
+    expression(): any;
+    makeLiteral(literalType: any, parserFn: any, token: any): Literal;
+    advanceUntil(endToken: any): any;
+    formatDispatch(): any;
+    anonymousFunction(body: any): Literal;
+    closeParentheses(tt: any): ")" | "}" | "]" | undefined;
+    checkLiteralParsers(): void;
+}
+export class PocketLisp {
+    constructor(options: any, literals: any);
+    literals: any;
+    interpreter: Interpreter;
+    insituexecute(source: any): any;
+    execute(source: any): any;
+    evalFn(fn: any, args: any): any;
+}
+export class RuntimeError extends Error {
+    constructor(error: any, position: any);
+    stack: any;
+    _position: any;
+    get position(): any;
+}
+export namespace RuntimeError {
+    let kind: string;
+}
+export class Scanner {
+    constructor(source: any);
+    source: any;
+    start: number;
+    current: number;
+    line: number;
+    isEnd(): boolean;
+    advance(): any;
+    peek(): any;
+    peekNext(): any;
+    makeToken(type: any): Token;
+    makeStringToken(): Token;
+    errorToken(message: any): Token;
+    identifier(): Token;
+    makeIdentifierToken(): Token;
+    keyword(): Token;
+    number(): Token;
+    string(): Token;
+    skipWhitespace(): number | undefined;
+    scanToken(): Token;
+    scanAllToken(): Token[];
+}
+export class SnippetPosition {
+    constructor(source: any, startIndex: any, endIndex: any, line: any);
+    source: any;
+    startIndex: any;
+    endIndex: any;
+    line: any;
+    offset: number | undefined;
+    get start(): number;
+    get end(): number;
+    get length(): number;
+    getLineOffset(): number;
+}
+export namespace SnippetPosition {
+    let unknown: SnippetPosition;
+}
+export function simpleFunction(fn: any, arity: any): PLFunction;
+declare class Environment {
+    constructor(enclosing?: null);
+    enclosing: any;
+    values: any;
+    locked: any;
+    define(name: any, value: any, locked?: boolean): void;
+    get(name: any): any;
+    assign(name: any, value: any): any;
+    getNames(): string[];
+    get parent(): any;
+}
+declare class Token {
+    constructor(type: any, value: any, position: any);
+    type: any;
+    value: any;
+    position: any;
+}
+declare namespace Token {
+    let INIT: Token;
+}
+declare class Literal {
+    constructor(kind: any, value: any, position: any);
+    kind: any;
+    value: any;
+    position: any;
+}
+declare class PLFunction {
+    constructor(_fn: any, _arity: any, _resolveIds?: boolean, _toString?: string);
+    _fn: any;
+    _arity: any;
+    _resolveIds: boolean;
+    _toString: string;
+    call(interpreter: any, env: any, args: any): any;
+    get arity(): any;
+    toString(): string;
+    toJS(): string;
+    debugTypeOf(): string;
+}
+declare namespace PLFunction {
+    let kind_1: string;
+    export { kind_1 as kind };
+}
+export {};