@treenity/core 1.0.13

package/CHANGELOG.md

@@ -0,0 +1,56 @@
+# @treenity/core
+
+## 1.0.13
+
+### Patch Changes
+
+- Updated packages version
+- Updated dependencies
+  - @treenity/js-shared@1.0.12
+
+## 1.0.12
+
+### Patch Changes
+
+- Updated libs
+- Updated dependencies
+  - @treenity/js-shared@1.0.11
+
+## 1.0.11
+
+### Patch Changes
+
+- Changed version
+- Updated dependencies
+  - @treenity/js-shared@1.0.10
+
+## 1.0.10
+
+### Patch Changes
+
+- Updated libs
+- Updated dependencies
+  - @treenity/js-shared@1.0.9
+
+## 1.0.9
+
+### Patch Changes
+
+- Updated dependencies
+  - @treenity/js-shared@1.0.8
+
+## 1.0.8
+
+### Patch Changes
+
+- Updated versions
+- Updated dependencies
+  - @treenity/js-shared@1.0.5
+
+## 1.0.7
+
+### Patch Changes
+
+- Updated version to update new front-proxy
+- Updated dependencies
+  - @treenity/js-shared@1.0.4

package/README.md

@@ -0,0 +1,18 @@
+# @treenity/core docs
+### Installation
+Create token with "api" **scope** [here](https://gitlab.com/-/profile/personal_access_tokens).
+Add private registry info to .npmrc file in root of project
+```
+@cluster:registry=https://gitlab.com/api/v4/projects/35830151/packages/npm/
+//gitlab.com/api/v4/projects/35830151/packages/npm/:_authToken=${TOKEN}
+```
+Install:
+```
+TOKEN=<access_token> npm i @cluster/protocol
+```
+
+### Publish new version
+To publish new version you need gilab api access key:
+```bash
+MY_TOKEN=<access_token> npm publish
+```

package/dist/context.d.ts

@@ -0,0 +1,84 @@
+import { Obj } from '@treenity/js-shared';
+import * as React from 'react';
+import { PropsWithChildren } from 'react';
+import { JsonObjectSchema } from './contexts/json-schema/types';
+import { PortTypeData } from './contexts/react/types';
+import { Meta, Node } from './meta';
+export interface TypeContextInfo<C, O> {
+    id: string;
+    context: string;
+    subContext: string;
+    component: C;
+    options: O;
+}
+export interface Context<C, O> {
+    name: string;
+    add(typeName: string, component: C, options: O): TypeContextInfo<C, O>;
+    add(subContext: string, typeName: string, component: C, options: O): TypeContextInfo<C, O>;
+    get(typeName: string): Promise<[C, O]>;
+    get(subContext: string, typeName: string): Promise<[C, O]>;
+    getInfo(typeName: string): Promise<TypeContextInfo<C, O>>;
+    getInfo(subContext: string, typeName: string): Promise<TypeContextInfo<C, O>>;
+    search(query: string): TypeContextInfo<C, O>[];
+}
+export declare class ContextImpl<C, O> implements Context<C, O> {
+    name: string;
+    items: Map<string, TypeContextInfo<C, O>>;
+    constructor(name: string);
+    add(...args: any[]): TypeContextInfo<C, O>;
+    getInfo(subContext: string, typeName?: string): Promise<TypeContextInfo<C, O>>;
+    get(subContext: string, typeName?: string): Promise<[C, O]>;
+    search(query: string): TypeContextInfo<C, O>[];
+}
+export interface ReactContextOptions {
+    props?: Obj<any>;
+    ports?: PortTypeData;
+}
+export interface IReactContextProps<T extends Meta = Meta> extends PropsWithChildren {
+    value: T;
+    node: Node;
+    onChange(setter: (m: T) => T | void): void;
+    onChangeNode(setter: (node: Node) => Node | void): void;
+}
+export type ReactTypeContextInfo = TypeContextInfo<React.FC<IReactContextProps>, ReactContextOptions>;
+export interface ReactTypeContext extends Context<React.FC<IReactContextProps>, ReactContextOptions> {
+}
+export interface Service {
+    run(params: {
+        meta: Meta;
+        node: Node;
+    }): Promise<void>;
+}
+export interface ServiceContextOptions {
+}
+export interface ServiceTypeContext extends Context<Service, ServiceContextOptions> {
+}
+export type ScriptNode = (...params: any[]) => any;
+export interface NodeEngineContextOptions {
+    ports: PortTypeData;
+}
+export type NodeEngineTypeContextInfo = TypeContextInfo<ScriptNode, NodeEngineContextOptions>;
+export interface NodeEngineTypeContext extends Context<ScriptNode, NodeEngineContextOptions> {
+}
+export interface MetaContextOptions {
+}
+export interface MetaTypeContext extends Context<JsonObjectSchema, MetaContextOptions> {
+}
+export interface ProtoTypeContextOptions {
+}
+export interface Protocol {
+    fetch(url: string): Promise<any>;
+}
+export interface ProtoTypeContext extends Context<Protocol, ProtoTypeContextOptions> {
+}
+export interface ContextTypes {
+    react: ReactTypeContext;
+    jsSrv: ServiceTypeContext;
+    meta: MetaTypeContext;
+    proto: ProtoTypeContext;
+    noflo: NodeEngineTypeContext;
+}
+export declare const types: ContextTypes;
+export interface Process {
+    createChild(): void;
+}

package/dist/context.mjs

@@ -0,0 +1,90 @@
+import { capitalize } from '@treenity/js-shared/utils';
+import { SynchronousPromise } from 'synchronous-promise';
+
+class ContextImpl {
+    name;
+    items = new Map();
+    constructor(name) {
+        this.name = name;
+        // @ts-ignore
+        types[name] = this;
+    }
+    // add(...args: Pro<Context<C, O>['add']>): TypeContextInfo<C, O>;
+    // add(...args: ArgumentTypes<Context<C, O>['add']>): TypeContextInfo<C, O> {
+    add(...args) {
+        if (args.length < 3)
+            args.unshift('');
+        const [subContext, typeName, component, options] = args;
+        const contextType = subContext ? subContext + ':' + typeName : typeName;
+        const t = {
+            id: contextType,
+            context: this.name,
+            subContext,
+            component,
+            options,
+        };
+        this.items.set(contextType, t);
+        return t;
+    }
+    // get(typeName: string): Promise<TypeContextInfo<C, O>>;
+    // get(subContext: string, typeName: string): Promise<TypeContextInfo<C, O>>;
+    getInfo(subContext, typeName) {
+        if (!typeName) {
+            typeName = subContext;
+            subContext = '';
+        }
+        const contextType = subContext ? subContext + ':' + typeName : typeName;
+        const item = this.items.get(contextType);
+        if (!item) {
+            return SynchronousPromise.reject(new Error('not found: ' + contextType));
+        }
+        return SynchronousPromise.resolve(item);
+    }
+    get(subContext, typeName) {
+        return this.getInfo(subContext, typeName).then(({ component, options }) => [
+            component,
+            options,
+        ]);
+    }
+    search(query) {
+        const result = [];
+        for (let t of this.items.values()) {
+            if (!t.subContext && (!query || t.id.includes(query)))
+                result.push(t);
+        }
+        return result;
+    }
+}
+class ReactTypeContextImpl extends ContextImpl {
+    add(...args) {
+        if (args.length === 4) {
+            const [, typeName, component] = args;
+            if (!component.displayName && !component.name)
+                component.displayName = capitalize(typeName);
+        }
+        else {
+            const [typeName, component] = args;
+            if (!component.displayName && !component.name)
+                component.displayName = capitalize(typeName);
+        }
+        return super.add(...args);
+    }
+}
+class ServiceTypeContextImpl extends ContextImpl {
+}
+class NodeEngineTypeContextImpl extends ContextImpl {
+}
+class MetaTypeContextImpl extends ContextImpl {
+}
+class ProtoTypeContextImpl extends ContextImpl {
+}
+// @ts-ignore
+const types = {};
+new ReactTypeContextImpl('react');
+new MetaTypeContextImpl('meta');
+new ProtoTypeContextImpl('proto');
+new ServiceTypeContextImpl('jsSrv');
+new NodeEngineTypeContextImpl('noflo');
+
+export { ContextImpl, types };
+//# sourceMappingURL=context.mjs.map

package/dist/contexts/json-schema/types.d.ts

@@ -0,0 +1,3 @@
+import { SomeJSONSchema } from 'ajv/lib/types/json-schema';
+import { JSONSchema } from 'json-schema-to-ts';
+export type JsonObjectSchema = SomeJSONSchema & JSONSchema;

package/dist/contexts/react/types.d.ts

@@ -0,0 +1,18 @@
+export interface PortTypeData {
+    in: Record<string, Omit<ISocket, 'name'> | string>;
+    out: Record<string, Omit<ISocket, 'name'> | string>;
+}
+export interface ISocket<D extends any = {}> {
+    id?: string;
+    name: string;
+    label?: string;
+    type: string;
+    dynamic?: boolean;
+    value?: D;
+    isComplex?: boolean;
+}
+export interface ISocketType {
+    name?: string;
+    label: string;
+    type: string;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './context';
+export * from './contexts/json-schema/types';
+export * from './contexts/react/types';
+export type { Node, NodeRef, NodeLink, Meta } from './meta';

package/dist/index.mjs

@@ -0,0 +1,2 @@
+export { ContextImpl, types } from './context.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/loading.d.ts

@@ -0,0 +1,8 @@
+/**
+ * How we're loading the system
+ * 1. Loading root json object, containing root node - from db, or fs, or something
+ * 2. Start current context: node, or browser, or go, or deno, python...
+ * 3. load components for metas in node
+ * 4. run components one by one
+ */
+export {};

package/dist/meta.d.ts

@@ -0,0 +1,31 @@
+export interface Meta {
+    $id: string;
+    $name: string;
+    $anchor?: string;
+    $type: string;
+    $perm?: MetaPermission;
+    $tg?: string[];
+}
+export type MetaPermission = Record<string, Array<string>>;
+export interface NodeRef {
+    ref: string;
+    url: string;
+}
+export interface NodeLink {
+    p: string;
+    v: string;
+}
+export interface Node extends Meta {
+    $parid: string;
+    /**
+     * if ref exists in $refs, then field value will be replaced with value pointed by NodeRef.url
+     */
+    $refs: NodeRef[];
+    path: string;
+    links?: NodeLink[];
+    defaultMeta?: string;
+    title: string;
+    metas: {
+        [name: string]: Meta;
+    };
+}