ghostos 0.1.14 → 0.1.16

package/README.dev.md

@@ -1,20 +1,25 @@
 ## Publishing on npmjs
 
 ### Build package and sanity-check the tarball
+
 ```bash
 npm ci
 npm run build
 npm pack             # creates ./ghostos-x.y.z.tgz
 tar -tf ghostos-*.tgz  # confirm only the files you expect are inside
 ```
+
 ### Test the package for installability locally
+
 ```bash
 mkdir /tmp/pkg-test && cd /tmp/pkg-test
 npm init -y
 npm i /path/to/ghostos-x.y.z.tgz
 node -e "import('ghostos').then(m=>console.log(Object.keys(m)))"
 ```
+
 ### Log in and publish on npmjs
+
 ```bash
 npm login                          # enter your npmjs.com credentials
 npm publish                        # publish

package/README.md

@@ -1,4 +1,5 @@
 # ghostos
+
 A reference LEAF parser implementation used by leafgon.com
 
 ## Node setup
@@ -8,19 +9,23 @@ npm i ghostos
 ```
 
 ## getting graph data from leafgon.com
+
 ```bash
 gq https://gdb.leafgon.com/qmgraphql -q 'query {graph: getGraph(domain: "breezyforest", appid: "testbed", filter: {}) {domain appid nodes {uuid leafnodetype out_edges {uuid source {uuid} target {uuid} data} data} edges { uuid source {uuid} target {uuid} } }}' > ./tests/breezyforest-testbed.json
 ```
 
 ## GitHub-hosted leafgraphs
+
 Leafgraphs can be loaded from GitHub raw JSON by using `github` as the domain and a repo filepath as the appid.
 
 Format:
+
 - `github/<github-user>/<repo>/<path>`
 - `github/<github-user>/<repo>@<ref>/<path>` (optional ref, default `main`)
 - `github/<github-user>/<repo>/<path>?token=<some token>`
 
 Example:
+
 - `github/leafgon/leafgraphs/tests/breezyforest-testbed`
 - `github/leafgon/leafgraphs@dev/tests/breezyforest-testbed`
 - `github/leafgon/leafgraphs/tests/breezyforest-testbed?token=abc123`
@@ -28,4 +33,5 @@ Example:
 See `docs/github-leafgraphs.md` for end-user documentation.
 
 ## Leafgon-hosted leafgraphs
+
 See `docs/leafgon-leafgraphs.md` for end-user documentation.

package/lib/api/leafio/core.d.ts

@@ -0,0 +1,301 @@
+export function useLEAFIOapi({ _LEAFappList, stateObjInstanceID, dirOfSubjects, permissions, metamodel, }?: {
+    _LEAFappList?: never[] | undefined;
+    stateObjInstanceID?: string | undefined;
+    dirOfSubjects?: {} | undefined;
+    permissions?: {} | undefined;
+    metamodel?: {
+        breezyforest: {
+            _version: string;
+            _nickname: string;
+            scaffold: {
+                map: {
+                    leaf: {
+                        logic: {
+                            type: string;
+                            args: {};
+                        };
+                        provenance: {
+                            api: string;
+                            uuid: string;
+                            graph: {
+                                appuuid: string;
+                                name: string;
+                                version: string;
+                            };
+                        };
+                        appdata: {};
+                    };
+                };
+                directory: {
+                    api: string[];
+                    logic: string[];
+                    type: string[];
+                    args: string[];
+                    provenance: string[];
+                    uuid: string[];
+                    leafapp: string[];
+                    appdata: string[];
+                };
+                fetch: (n_e: any, crawlkey: any) => any;
+            };
+            originType: {
+                FRONTEND: number;
+                BACKEND: number;
+                SCREEN: number;
+            };
+            subsDirectory: {
+                readmefirst: {};
+                leaflake: {
+                    bridges: {
+                        gql: string;
+                    };
+                };
+                appintent: {};
+                appmodel: {};
+                appview: {};
+                osview: {};
+                osview2: {};
+                dataflowplane: {};
+                appcache: {};
+            };
+            IOAccessPermission: {
+                Owner: number;
+                Observer: number;
+                Contributor: number;
+                All: number;
+            };
+            IOStateGroundZero: {
+                dirOfSubjects: {};
+                subsCache: {};
+                subscriptions: {};
+                callbacks: {};
+                permissions: {};
+            };
+            GQLParameters: {
+                clientconfig_full: {
+                    keepGQLConnected: boolean;
+                    dburi_subs: string | undefined;
+                    dburi_subs_ws: string | undefined;
+                    dburi_qm: string | undefined;
+                };
+                clientconfig_sub: {
+                    keepGQLConnected: boolean;
+                    dburi_subs: string | undefined;
+                    dburi_subs_ws: string | undefined;
+                };
+                clientconfig_qm: {
+                    dburi_qm: string | undefined;
+                };
+                masterquery: string;
+            };
+            LEAFdictionary: {
+                map: typeof import("rxjs").map;
+            };
+        };
+    } | undefined;
+}): {
+    getCurLEAFIOState: () => any;
+    getMasterSubsDir: () => any;
+    setNewLEAFIOState: (key: any, state: any, dataOrigin?: number) => number | true;
+    setLEAFIOCallback: (key: any, callerid: any, callbackFunc?: null) => void;
+};
+export function initLEAFIOapi({ _LEAFappList, stateObjInstanceID, dirOfSubjects, permissions, metamodel, }?: {
+    _LEAFappList?: never[] | undefined;
+    stateObjInstanceID?: string | undefined;
+    dirOfSubjects?: {} | undefined;
+    permissions?: {} | undefined;
+    metamodel?: {
+        breezyforest: {
+            _version: string;
+            _nickname: string;
+            scaffold: {
+                map: {
+                    leaf: {
+                        logic: {
+                            type: string;
+                            args: {};
+                        };
+                        provenance: {
+                            api: string;
+                            uuid: string;
+                            graph: {
+                                appuuid: string;
+                                name: string;
+                                version: string;
+                            };
+                        };
+                        appdata: {};
+                    };
+                };
+                directory: {
+                    api: string[];
+                    logic: string[];
+                    type: string[];
+                    args: string[];
+                    provenance: string[];
+                    uuid: string[];
+                    leafapp: string[];
+                    appdata: string[];
+                };
+                fetch: (n_e: any, crawlkey: any) => any;
+            };
+            originType: {
+                FRONTEND: number;
+                BACKEND: number;
+                SCREEN: number;
+            };
+            subsDirectory: {
+                readmefirst: {};
+                leaflake: {
+                    bridges: {
+                        gql: string;
+                    };
+                };
+                appintent: {};
+                appmodel: {};
+                appview: {};
+                osview: {};
+                osview2: {};
+                dataflowplane: {};
+                appcache: {};
+            };
+            IOAccessPermission: {
+                Owner: number;
+                Observer: number;
+                Contributor: number;
+                All: number;
+            };
+            IOStateGroundZero: {
+                dirOfSubjects: {};
+                subsCache: {};
+                subscriptions: {};
+                callbacks: {};
+                permissions: {};
+            };
+            GQLParameters: {
+                clientconfig_full: {
+                    keepGQLConnected: boolean;
+                    dburi_subs: string | undefined;
+                    dburi_subs_ws: string | undefined;
+                    dburi_qm: string | undefined;
+                };
+                clientconfig_sub: {
+                    keepGQLConnected: boolean;
+                    dburi_subs: string | undefined;
+                    dburi_subs_ws: string | undefined;
+                };
+                clientconfig_qm: {
+                    dburi_qm: string | undefined;
+                };
+                masterquery: string;
+            };
+            LEAFdictionary: {
+                map: typeof import("rxjs").map;
+            };
+        };
+    } | undefined;
+}): {
+    getCurLEAFIOState: () => any;
+    getMasterSubsDir: () => any;
+    setNewLEAFIOState: (key: any, state: any, dataOrigin?: number) => number | true;
+    setLEAFIOCallback: (key: any, callerid: any, callbackFunc?: null) => void;
+    destructLEAFIOobj: () => void;
+};
+export function initializeMasterSubsDirectory(_stateObjInstanceID: any, _LEAFappList?: any[], _metamodel?: {
+    breezyforest: {
+        _version: string;
+        _nickname: string;
+        scaffold: {
+            map: {
+                leaf: {
+                    logic: {
+                        type: string;
+                        args: {};
+                    };
+                    provenance: {
+                        api: string;
+                        uuid: string;
+                        graph: {
+                            appuuid: string;
+                            name: string;
+                            version: string;
+                        };
+                    };
+                    appdata: {};
+                };
+            };
+            directory: {
+                api: string[];
+                logic: string[];
+                type: string[];
+                args: string[];
+                provenance: string[];
+                uuid: string[];
+                leafapp: string[];
+                appdata: string[];
+            };
+            fetch: (n_e: any, crawlkey: any) => any;
+        };
+        originType: {
+            FRONTEND: number;
+            BACKEND: number;
+            SCREEN: number;
+        };
+        subsDirectory: {
+            readmefirst: {};
+            leaflake: {
+                bridges: {
+                    gql: string;
+                };
+            };
+            appintent: {};
+            appmodel: {};
+            appview: {};
+            osview: {};
+            osview2: {};
+            dataflowplane: {};
+            appcache: {};
+        };
+        IOAccessPermission: {
+            Owner: number;
+            Observer: number;
+            Contributor: number;
+            All: number;
+        };
+        IOStateGroundZero: {
+            dirOfSubjects: {};
+            subsCache: {};
+            subscriptions: {};
+            callbacks: {};
+            permissions: {};
+        };
+        GQLParameters: {
+            clientconfig_full: {
+                keepGQLConnected: boolean;
+                dburi_subs: string | undefined;
+                dburi_subs_ws: string | undefined;
+                dburi_qm: string | undefined;
+            };
+            clientconfig_sub: {
+                keepGQLConnected: boolean;
+                dburi_subs: string | undefined;
+                dburi_subs_ws: string | undefined;
+            };
+            clientconfig_qm: {
+                dburi_qm: string | undefined;
+            };
+            masterquery: string;
+        };
+        LEAFdictionary: {
+            map: typeof import("rxjs").map;
+        };
+    };
+}): any[];
+export function initializeSubsMain(): {
+    handle$: BehaviorSubject<any>;
+    doWrite: (_data: any) => void;
+    doSubscribe: (_eventCallback: any) => import("rxjs").Subscription;
+    doUnsubscribe: (subscription: any) => any;
+    doAddAddressee: (gqlrequest: any, nodeuuid: any) => void;
+};
+import { BehaviorSubject } from "rxjs";

package/lib/api/leafio/leafgql.d.ts

@@ -0,0 +1,30 @@
+export function getLEAFgqlStrAddNode(node_input: any): string;
+export function getLEAFgqlStrUpdateNode(node_input: any): string;
+export function getLEAFgqlStrDelNode(node_uuid: any): string;
+export function getLEAFgqlSubs(graph: any): string;
+export function mutateUpdateNode({ variables, endpoint }: {
+    variables: any;
+    endpoint?: string | undefined;
+}): Promise<void>;
+export function mutateAddNode({ variables, endpoint }: {
+    variables: any;
+    endpoint?: string | undefined;
+}): Promise<void>;
+export function mutateDelNode({ node_uuid, endpoint }: {
+    node_uuid: any;
+    endpoint?: string | undefined;
+}): Promise<void>;
+export function mutateAddEdge({ variables, endpoint }: {
+    variables: any;
+    endpoint?: string | undefined;
+}): Promise<void>;
+export function mutateDelEdge({ edge_uuid, endpoint }: {
+    edge_uuid: any;
+    endpoint?: string | undefined;
+}): Promise<void>;
+export const MUT_UPDATENODE: "mutation UpdateNode($uuid: String!, $data: String!) {\n  updateNode(input: {filter: {uuid: {eq: $uuid}}, set: {data: $data}}) {node {uuid}}\n}";
+export const MUT_ADDNODE: "mutation AddNode($uuid: String!, $leafnodetype: String, $data: String!, $graphdomain: String!, $graphappid: String!, $provdomain: String!, $provappid: String!) {\n  addNode(input: [{uuid: $uuid, leafnodetype: $leafnodetype, graph: {domain: $graphdomain, appid: $graphappid}, provenance: {domain: $provdomain, appid: $provappid}, data: $data}]) {node {uuid}}\n}";
+export const MUT_DELNODE: "mutation DeleteNode($uuid: String!) {\n  deleteNode(nfilter: {uuid: {eq: $uuid}}) {node {uuid}}\n}";
+export const endpoint_subs: string;
+export const websocket_subs: string;
+export const endpoint_qm: string;

package/lib/api/leafio/leaflake.d.ts

@@ -0,0 +1,100 @@
+export function initializeLEAFlakeGQLClient({ _clientConfig, _metamodel, _sessionid, }?: {
+    _clientConfig?: {
+        dburi_subs: string | undefined;
+        dburi_subs_ws: string | undefined;
+        dburi_qm: string | undefined;
+    } | undefined;
+    _metamodel?: {
+        _version: string;
+        _nickname: string;
+        scaffold: {
+            map: {
+                leaf: {
+                    logic: {
+                        type: string;
+                        args: {};
+                    };
+                    provenance: {
+                        api: string;
+                        uuid: string;
+                        graph: {
+                            appuuid: string;
+                            name: string;
+                            version: string;
+                        };
+                    };
+                    appdata: {};
+                };
+            };
+            directory: {
+                api: string[];
+                logic: string[];
+                type: string[];
+                args: string[];
+                provenance: string[];
+                uuid: string[];
+                leafapp: string[];
+                appdata: string[];
+            };
+            fetch: (n_e: any, crawlkey: any) => any;
+        };
+        originType: {
+            FRONTEND: number;
+            BACKEND: number;
+            SCREEN: number;
+        };
+        subsDirectory: {
+            readmefirst: {};
+            leaflake: {
+                bridges: {
+                    gql: string;
+                };
+            };
+            appintent: {};
+            appmodel: {};
+            appview: {};
+            osview: {};
+            osview2: {};
+            dataflowplane: {};
+            appcache: {};
+        };
+        IOAccessPermission: {
+            Owner: number;
+            Observer: number;
+            Contributor: number;
+            All: number;
+        };
+        IOStateGroundZero: {
+            dirOfSubjects: {};
+            subsCache: {};
+            subscriptions: {};
+            callbacks: {};
+            permissions: {};
+        };
+        GQLParameters: {
+            clientconfig_full: {
+                keepGQLConnected: boolean;
+                dburi_subs: string | undefined;
+                dburi_subs_ws: string | undefined;
+                dburi_qm: string | undefined;
+            };
+            clientconfig_sub: {
+                keepGQLConnected: boolean;
+                dburi_subs: string | undefined;
+                dburi_subs_ws: string | undefined;
+            };
+            clientconfig_qm: {
+                dburi_qm: string | undefined;
+            };
+            masterquery: string;
+        };
+        LEAFdictionary: {
+            map: typeof import("rxjs").map;
+        };
+    } | undefined;
+    _sessionid?: undefined;
+}): {
+    subscriptions: {};
+    subs_methods: {};
+    qm_methods: {};
+};

package/lib/api/leafio/leaflake.unit.test.d.ts

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

package/lib/api/metamodel.d.ts

@@ -0,0 +1,179 @@
+export namespace LEAFIOmetamodel {
+    namespace breezyforest {
+        let _version: string;
+        let _nickname: string;
+        namespace scaffold {
+            namespace map {
+                namespace leaf {
+                    namespace logic {
+                        let type: string;
+                        let args: {};
+                    }
+                    namespace provenance {
+                        let api: string;
+                        let uuid: string;
+                        namespace graph {
+                            let appuuid: string;
+                            let name: string;
+                            let version: string;
+                        }
+                    }
+                    let appdata: {};
+                }
+            }
+            namespace directory {
+                let api_1: string[];
+                export { api_1 as api };
+                let logic_1: string[];
+                export { logic_1 as logic };
+                let type_1: string[];
+                export { type_1 as type };
+                let args_1: string[];
+                export { args_1 as args };
+                let provenance_1: string[];
+                export { provenance_1 as provenance };
+                let uuid_1: string[];
+                export { uuid_1 as uuid };
+                export let leafapp: string[];
+                let appdata_1: string[];
+                export { appdata_1 as appdata };
+            }
+            function fetch(n_e: any, crawlkey: any): any;
+        }
+        namespace originType {
+            let FRONTEND: number;
+            let BACKEND: number;
+            let SCREEN: number;
+        }
+        namespace subsDirectory {
+            let readmefirst: {};
+            namespace leaflake {
+                namespace bridges {
+                    let gql: string;
+                }
+            }
+            let appintent: {};
+            let appmodel: {};
+            let appview: {};
+            let osview: {};
+            let osview2: {};
+            let dataflowplane: {};
+            let appcache: {};
+        }
+        namespace IOAccessPermission {
+            let Owner: number;
+            let Observer: number;
+            let Contributor: number;
+            let All: number;
+        }
+        namespace IOStateGroundZero {
+            let dirOfSubjects: {};
+            let subsCache: {};
+            let subscriptions: {};
+            let callbacks: {};
+            let permissions: {};
+        }
+        namespace GQLParameters {
+            namespace clientconfig_full {
+                export let keepGQLConnected: boolean;
+                export { endpoint_subs as dburi_subs };
+                export { websocket_subs as dburi_subs_ws };
+                export { endpoint_qm as dburi_qm };
+            }
+            namespace clientconfig_sub {
+                let keepGQLConnected_1: boolean;
+                export { keepGQLConnected_1 as keepGQLConnected };
+                export { endpoint_subs as dburi_subs };
+                export { websocket_subs as dburi_subs_ws };
+            }
+            namespace clientconfig_qm {
+                export { endpoint_qm as dburi_qm };
+            }
+            let masterquery: string;
+        }
+        namespace LEAFdictionary {
+            export { map };
+        }
+    }
+}
+export function _leafstdlib_dataflow_api(type: any): any;
+export namespace _breezyforeststdlib_hierarchy {
+    let io: string[];
+    let elements: string[];
+    let abstraction: string[];
+    let dataflow: string[];
+    let arcane: string[];
+}
+export namespace _edge_handle_dict {
+    namespace leaflambdaedge {
+        let sourceHandle: string;
+        let targetHandle: string;
+    }
+    namespace leafanchoredge {
+        let sourceHandle_1: string;
+        export { sourceHandle_1 as sourceHandle };
+        let targetHandle_1: string;
+        export { targetHandle_1 as targetHandle };
+    }
+    namespace leafdataedge {
+        let sourceHandle_2: string;
+        export { sourceHandle_2 as sourceHandle };
+        let targetHandle_2: string;
+        export { targetHandle_2 as targetHandle };
+    }
+}
+export namespace _edge_style_dict {
+    export namespace leaflambdaedge_1 {
+        let stroke: string;
+        let fillOpacity: number;
+    }
+    export { leaflambdaedge_1 as leaflambdaedge };
+    export namespace leafanchoredge_1 {
+        let stroke_1: string;
+        export { stroke_1 as stroke };
+        let fillOpacity_1: number;
+        export { fillOpacity_1 as fillOpacity };
+    }
+    export { leafanchoredge_1 as leafanchoredge };
+    export namespace leafdataedge_1 {
+        let stroke_2: string;
+        export { stroke_2 as stroke };
+        let fillOpacity_2: number;
+        export { fillOpacity_2 as fillOpacity };
+    }
+    export { leafdataedge_1 as leafdataedge };
+}
+export namespace _breezyforeststdlib_name {
+    let outport: string;
+    let inport: string;
+    let screenio: string;
+    let memoryio: string;
+    let spade: string;
+    let heart: string;
+    let diamond: string;
+    let club: string;
+    let element: string;
+    let anchor: string;
+    let leafgraph: string;
+    let lambda: string;
+    let spelldef: string;
+    let spell: string;
+    let loopyspell: string;
+    let label: string;
+    let delabel: string;
+    let bottle: string;
+    let unbottle: string;
+    let crate: string;
+    let config: string;
+    let chronos: string;
+    let async: string;
+    let sync: string;
+    let mix: string;
+    let gate: string;
+    let leaflisp: string;
+}
+declare const endpoint_subs: string | undefined;
+declare const websocket_subs: string | undefined;
+declare const endpoint_qm: string | undefined;
+import { map as map_1 } from "rxjs/operators";
+export {};

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

@@ -0,0 +1 @@
+export function getLEAFNodeCoreLogic(type: any, scope: any, lambdactrl: any): any;