@syncbridge/common 0.4.0

package/decorators/use-component.decorator.js

@@ -0,0 +1,24 @@
+import 'reflect-metadata';
+import { OWN_ELEMENT_METADATA } from '../constants.js';
+import { defineMergeMetadata } from './decorator-helpers.js';
+export function UseComponent(options) {
+    return function (target, propertyKey) {
+        /** c8 ignore next */
+        if (typeof propertyKey !== 'string')
+            throw new TypeError('Property key must be a string');
+        if (!options.className && !options.interfaces) {
+            const designType = Reflect.getMetadata('design:type', target, propertyKey);
+            if (typeof designType === 'function' && designType.interfaces) {
+                options.interfaces = [...designType.interfaces];
+            }
+        }
+        defineMergeMetadata(target.constructor, OWN_ELEMENT_METADATA, {
+            components: {
+                [propertyKey]: {
+                    ...options,
+                    propertyKey,
+                },
+            },
+        });
+    };
+}

package/decorators/use-variables.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import type { Type } from 'ts-gems';
+import type { ComponentBase } from '../classes/component-base.js';
+import type { ProcessorBase } from '../classes/processor-base.js';
+export declare function UseVariables<T extends ProcessorBase | ComponentBase>(variablesClass?: Type): (target: T, propertyKey: "values") => void;

package/decorators/use-variables.decorator.js

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { OWN_ELEMENT_METADATA, VARIABLE_CONTAINER } from '../constants.js';
+import { defineMergeMetadata } from './decorator-helpers.js';
+export function UseVariables(variablesClass) {
+    return function (target, propertyKey) {
+        /** c8 ignore next */
+        if (propertyKey !== 'values')
+            throw new TypeError('Property key must be "values"');
+        variablesClass =
+            variablesClass || Reflect.getMetadata('design:type', target, propertyKey);
+        if (!(typeof variablesClass === 'function' &&
+            Reflect.hasMetadata(VARIABLE_CONTAINER, variablesClass.prototype))) {
+            throw new TypeError('Variables class must be decorated with @DefineVariable');
+        }
+        const metadata = Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype);
+        defineMergeMetadata(target.constructor, OWN_ELEMENT_METADATA, {
+            variables: metadata,
+        });
+    };
+}

package/index.d.ts

@@ -0,0 +1,20 @@
+export * from './classes/base-element.js';
+export * from './classes/component-base.js';
+export * from './classes/frame-stream.js';
+export * from './classes/processor-base.js';
+export * from './classes/runnable.js';
+export * from './classes/sb-error.js';
+export * from './classes/stack-executor.js';
+export * from './constants.js';
+export * from './decorators/component.decorator.js';
+export * from './decorators/define-variable.decorator.js';
+export * from './decorators/processor.decorator.js';
+export * from './interfaces/index.js';
+export * from './models/index.js';
+export * as models from './models/index.js';
+export * from './models-document.js';
+export * from './processor-factory.js';
+export * from './registry.js';
+export * from './utils/make-extension-package.js';
+export * from './utils/metadata-utils.js';
+export * from './utils/profile-utils.js';

package/index.js

@@ -0,0 +1,20 @@
+export * from './classes/base-element.js';
+export * from './classes/component-base.js';
+export * from './classes/frame-stream.js';
+export * from './classes/processor-base.js';
+export * from './classes/runnable.js';
+export * from './classes/sb-error.js';
+export * from './classes/stack-executor.js';
+export * from './constants.js';
+export * from './decorators/component.decorator.js';
+export * from './decorators/define-variable.decorator.js';
+export * from './decorators/processor.decorator.js';
+export * from './interfaces/index.js';
+export * from './models/index.js';
+export * as models from './models/index.js';
+export * from './models-document.js';
+export * from './processor-factory.js';
+export * from './registry.js';
+export * from './utils/make-extension-package.js';
+export * from './utils/metadata-utils.js';
+export * from './utils/profile-utils.js';

package/interfaces/extension-package.interface.d.ts

@@ -0,0 +1,6 @@
+import type { Type } from 'ts-gems';
+export interface IExtensionPackage {
+    components: Type[];
+    processors: Type[];
+    dependencies?: string[];
+}

package/interfaces/extension-package.interface.js

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

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extension-package.interface.js';
+export * from './logger.interface.js';

package/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './extension-package.interface.js';
+export * from './logger.interface.js';

package/interfaces/logger.interface.d.ts

@@ -0,0 +1,17 @@
+export interface ILogger {
+    fatal: LeveledLogMethod;
+    critical: LeveledLogMethod;
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    info: LeveledLogMethod;
+    trace: LeveledLogMethod;
+    debug: LeveledLogMethod;
+    level: string;
+    child(options: Object): ILogger;
+    close(): void;
+}
+export interface LeveledLogMethod {
+    (message: string, ...meta: any[]): ILogger;
+    (message: any): ILogger;
+    (infoObject: object): ILogger;
+}

package/interfaces/logger.interface.js

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

package/models/enums/log-level.d.ts

@@ -0,0 +1,9 @@
+export declare enum LogLevel {
+    none = "none",
+    error = "error",
+    warn = "warn",
+    info = "info",
+    verbose = "verbose",
+    debug = "debug",
+    silly = "silly"
+}

package/models/enums/log-level.js

@@ -0,0 +1,15 @@
+import { EnumType } from '@opra/common';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["none"] = "none";
+    LogLevel["error"] = "error";
+    LogLevel["warn"] = "warn";
+    LogLevel["info"] = "info";
+    LogLevel["verbose"] = "verbose";
+    LogLevel["debug"] = "debug";
+    LogLevel["silly"] = "silly";
+})(LogLevel || (LogLevel = {}));
+EnumType(LogLevel, {
+    name: 'LogLevel',
+    description: 'Logging levels',
+});

package/models/enums/service-status.d.ts

@@ -0,0 +1,8 @@
+export declare enum ServiceStatus {
+    stopped = "stopped",
+    starting = "starting",
+    started = "started",
+    unhealthy = "unhealthy",
+    stopping = "stopping",
+    invalid = "invalid"
+}

package/models/enums/service-status.js

@@ -0,0 +1,14 @@
+import { EnumType } from '@opra/common';
+export var ServiceStatus;
+(function (ServiceStatus) {
+    ServiceStatus["stopped"] = "stopped";
+    ServiceStatus["starting"] = "starting";
+    ServiceStatus["started"] = "started";
+    ServiceStatus["unhealthy"] = "unhealthy";
+    ServiceStatus["stopping"] = "stopping";
+    ServiceStatus["invalid"] = "invalid";
+})(ServiceStatus || (ServiceStatus = {}));
+EnumType(ServiceStatus, {
+    name: 'ServiceStatus',
+    description: 'Status of any service',
+});

package/models/enums/variable-format.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum VariableFormat {
+    Base64 = "base64",
+    Hex = "hex",
+    Url = "url",
+    Email = "email",
+    Date = "date",
+    DateTime = "date-time",
+    Time = "time"
+}

package/models/enums/variable-format.enum.js

@@ -0,0 +1,15 @@
+import { EnumType } from '@opra/common';
+export var VariableFormat;
+(function (VariableFormat) {
+    VariableFormat["Base64"] = "base64";
+    VariableFormat["Hex"] = "hex";
+    VariableFormat["Url"] = "url";
+    VariableFormat["Email"] = "email";
+    VariableFormat["Date"] = "date";
+    VariableFormat["DateTime"] = "date-time";
+    VariableFormat["Time"] = "time";
+})(VariableFormat || (VariableFormat = {}));
+EnumType(VariableFormat, {
+    name: 'VariableFormat',
+    description: 'Format of string variable',
+});

package/models/enums/variable-type.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum VariableType {
+    String = "string",
+    Secret = "secret",
+    Number = "number",
+    Boolean = "boolean",
+    Nested = "nested",
+    Enum = "enum"
+}

package/models/enums/variable-type.enum.js

@@ -0,0 +1,14 @@
+import { EnumType } from '@opra/common';
+export var VariableType;
+(function (VariableType) {
+    VariableType["String"] = "string";
+    VariableType["Secret"] = "secret";
+    VariableType["Number"] = "number";
+    VariableType["Boolean"] = "boolean";
+    VariableType["Nested"] = "nested";
+    VariableType["Enum"] = "enum";
+})(VariableType || (VariableType = {}));
+EnumType(VariableType, {
+    name: 'VariableType',
+    description: 'Data type of the variable',
+});

package/models/index.d.ts

@@ -0,0 +1,13 @@
+export * from './enums/log-level.js';
+export * from './enums/service-status.js';
+export * from './enums/variable-format.enum.js';
+export * from './enums/variable-type.enum.js';
+export * from './metadata/author-metadata.js';
+export * from './metadata/component-metadata.js';
+export * from './metadata/element-component-metadata.js';
+export * from './metadata/element-metadata.js';
+export * from './metadata/processor-metadata.js';
+export * from './metadata/variable-metadata.js';
+export * from './profile/log-options.js';
+export * from './profile/profile.js';
+export * from './profile/profile-component.js';

package/models/index.js

@@ -0,0 +1,13 @@
+export * from './enums/log-level.js';
+export * from './enums/service-status.js';
+export * from './enums/variable-format.enum.js';
+export * from './enums/variable-type.enum.js';
+export * from './metadata/author-metadata.js';
+export * from './metadata/component-metadata.js';
+export * from './metadata/element-component-metadata.js';
+export * from './metadata/element-metadata.js';
+export * from './metadata/processor-metadata.js';
+export * from './metadata/variable-metadata.js';
+export * from './profile/log-options.js';
+export * from './profile/profile.js';
+export * from './profile/profile-component.js';

package/models/metadata/author-metadata.d.ts

@@ -0,0 +1,8 @@
+export declare class AuthorMetadata {
+    constructor(init?: Partial<AuthorMetadata>);
+    name?: string;
+    email?: string;
+    url?: string;
+    logoUrl?: string;
+    iconUrl?: string;
+}

package/models/metadata/author-metadata.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+let AuthorMetadata = class AuthorMetadata {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+};
+__decorate([
+    ApiField({
+        label: 'Name',
+        description: 'Name of the author. This is used to identify the author. ',
+    }),
+    __metadata("design:type", String)
+], AuthorMetadata.prototype, "name", void 0);
+__decorate([
+    ApiField({
+        label: 'Email',
+        description: 'Email of the author',
+    }),
+    __metadata("design:type", String)
+], AuthorMetadata.prototype, "email", void 0);
+__decorate([
+    ApiField({
+        label: 'Url',
+        description: 'Url of the author',
+    }),
+    __metadata("design:type", String)
+], AuthorMetadata.prototype, "url", void 0);
+__decorate([
+    ApiField({
+        label: 'Logo Url',
+        description: 'Url of the author logo. Dimensions should be 800x600, 400x300',
+    }),
+    __metadata("design:type", String)
+], AuthorMetadata.prototype, "logoUrl", void 0);
+__decorate([
+    ApiField({
+        label: 'Logomark Url',
+        description: 'Url of the author logomark. Dimensions should be square',
+    }),
+    __metadata("design:type", String)
+], AuthorMetadata.prototype, "iconUrl", void 0);
+AuthorMetadata = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], AuthorMetadata);
+export { AuthorMetadata };

package/models/metadata/component-metadata.d.ts

@@ -0,0 +1,8 @@
+import { ElementMetadata } from './element-metadata.js';
+/**
+ *
+ */
+export declare class ComponentMetadata extends ElementMetadata {
+    constructor(init?: Partial<ComponentMetadata>);
+    interfaces: string[];
+}

package/models/metadata/component-metadata.js

@@ -0,0 +1,25 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { ElementMetadata } from './element-metadata.js';
+/**
+ *
+ */
+let ComponentMetadata = class ComponentMetadata extends ElementMetadata {
+    constructor(init) {
+        super(init);
+    }
+};
+__decorate([
+    ApiField({
+        label: 'Interfaces',
+        description: 'Interfaces which this component implemented',
+        type: 'string',
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], ComponentMetadata.prototype, "interfaces", void 0);
+ComponentMetadata = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ComponentMetadata);
+export { ComponentMetadata };

package/models/metadata/element-component-metadata.d.ts

@@ -0,0 +1,19 @@
+import { VariableMetadataRecord } from './variable-metadata.js';
+/**
+ *
+ */
+export declare class ElementComponentMetadataRecord {
+    [key: string]: ElementComponentMetadata;
+}
+/**
+ *
+ */
+export declare class ElementComponentMetadata {
+    propertyKey?: string;
+    className?: string;
+    description?: string;
+    interfaces?: string[];
+    required?: boolean;
+    variables?: VariableMetadataRecord;
+    components?: ElementComponentMetadataRecord;
+}

package/models/metadata/element-component-metadata.js

@@ -0,0 +1,70 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { VariableMetadataRecord } from './variable-metadata.js';
+/**
+ *
+ */
+let ElementComponentMetadataRecord = class ElementComponentMetadataRecord {
+};
+ElementComponentMetadataRecord = __decorate([
+    ComplexType({
+        description: 'Container for processor components',
+        additionalFields: () => ElementComponentMetadata,
+    })
+], ElementComponentMetadataRecord);
+export { ElementComponentMetadataRecord };
+/**
+ *
+ */
+let ElementComponentMetadata = class ElementComponentMetadata {
+    propertyKey;
+};
+__decorate([
+    ApiField({
+        description: 'Class name of the component',
+        type: 'string',
+    }),
+    __metadata("design:type", String)
+], ElementComponentMetadata.prototype, "className", void 0);
+__decorate([
+    ApiField({
+        description: 'Description of the component',
+        type: 'string',
+    }),
+    __metadata("design:type", String)
+], ElementComponentMetadata.prototype, "description", void 0);
+__decorate([
+    ApiField({
+        description: 'Interfaces should be implemented by the component. This value is ignored if className is set',
+        type: 'string',
+        required: true,
+        examples: ['IoComponent'],
+    }),
+    __metadata("design:type", Array)
+], ElementComponentMetadata.prototype, "interfaces", void 0);
+__decorate([
+    ApiField({
+        description: 'Determine if the component is required or not',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], ElementComponentMetadata.prototype, "required", void 0);
+__decorate([
+    ApiField({
+        description: 'Variables to be overridden',
+    }),
+    __metadata("design:type", VariableMetadataRecord)
+], ElementComponentMetadata.prototype, "variables", void 0);
+__decorate([
+    ApiField({
+        label: 'Components',
+        description: 'Components settings of the processor',
+    }),
+    __metadata("design:type", ElementComponentMetadataRecord)
+], ElementComponentMetadata.prototype, "components", void 0);
+ElementComponentMetadata = __decorate([
+    ComplexType({
+        description: 'User defined variable definition',
+    })
+], ElementComponentMetadata);
+export { ElementComponentMetadata };

package/models/metadata/element-metadata.d.ts

@@ -0,0 +1,18 @@
+import { AuthorMetadata } from './author-metadata.js';
+import type { ElementComponentMetadataRecord } from './element-component-metadata.js';
+import { VariableMetadataRecord } from './variable-metadata.js';
+/**
+ *
+ */
+export declare class ElementMetadata {
+    constructor(init?: Partial<ElementMetadata>);
+    abstract?: boolean;
+    className: string;
+    displayName: string;
+    iconUrl?: string;
+    description?: string;
+    author: AuthorMetadata;
+    variables?: VariableMetadataRecord;
+    components?: ElementComponentMetadataRecord;
+    tags: string[];
+}

package/models/metadata/element-metadata.js

@@ -0,0 +1,81 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { AuthorMetadata } from './author-metadata.js';
+import { VariableMetadataRecord } from './variable-metadata.js';
+/**
+ *
+ */
+let ElementMetadata = class ElementMetadata {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+    abstract;
+};
+__decorate([
+    ApiField({
+        label: 'Class Name',
+        description: 'Uniquely identifies the element (camelCase, PascalCase)',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], ElementMetadata.prototype, "className", void 0);
+__decorate([
+    ApiField({
+        label: 'Name',
+        description: 'Human friendly name',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], ElementMetadata.prototype, "displayName", void 0);
+__decorate([
+    ApiField({
+        label: 'Icon',
+        description: 'Icon url',
+    }),
+    __metadata("design:type", String)
+], ElementMetadata.prototype, "iconUrl", void 0);
+__decorate([
+    ApiField({
+        label: 'Description',
+        description: 'Long description',
+    }),
+    __metadata("design:type", String)
+], ElementMetadata.prototype, "description", void 0);
+__decorate([
+    ApiField({
+        label: 'Author',
+        description: 'Author',
+    }),
+    __metadata("design:type", AuthorMetadata)
+], ElementMetadata.prototype, "author", void 0);
+__decorate([
+    ApiField({
+        label: 'Variables',
+        description: 'User defined variables',
+    }),
+    __metadata("design:type", VariableMetadataRecord)
+], ElementMetadata.prototype, "variables", void 0);
+__decorate([
+    ApiField({
+        type: async () => (await import('./element-component-metadata.js'))
+            .ElementComponentMetadataRecord,
+        label: 'Components',
+        description: 'Components',
+    }),
+    __metadata("design:type", Function)
+], ElementMetadata.prototype, "components", void 0);
+__decorate([
+    ApiField({
+        label: 'Tags',
+        description: 'Tags of the component. Tags are used to group components',
+        type: 'string',
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], ElementMetadata.prototype, "tags", void 0);
+ElementMetadata = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ElementMetadata);
+export { ElementMetadata };

package/models/metadata/package-metadata.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ */
+export declare class PackageMetadata {
+    constructor(init?: Partial<PackageMetadata>);
+    name: string;
+}

package/models/metadata/package-metadata.js

@@ -0,0 +1,27 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType, StringType } from '@opra/common';
+/**
+ *
+ */
+let PackageMetadata = class PackageMetadata {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+};
+__decorate([
+    ApiField({
+        label: 'Name',
+        description: 'Uniquely identifies the package',
+        required: true,
+        type: new StringType({
+            pattern: /^[a-z][a-z_-]+$/,
+        }),
+    }),
+    __metadata("design:type", String)
+], PackageMetadata.prototype, "name", void 0);
+PackageMetadata = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], PackageMetadata);
+export { PackageMetadata };

package/models/metadata/processor-metadata.d.ts

@@ -0,0 +1,5 @@
+import { ElementMetadata } from './element-metadata.js';
+export declare class ProcessorMetadata extends ElementMetadata {
+    constructor(init?: Partial<ProcessorMetadata>);
+    staticEvents?: Record<string, string>;
+}

package/models/metadata/processor-metadata.js

@@ -0,0 +1,14 @@
+import { __decorate, __metadata } from "tslib";
+import { ComplexType } from '@opra/common';
+import { ElementMetadata } from './element-metadata.js';
+let ProcessorMetadata = class ProcessorMetadata extends ElementMetadata {
+    constructor(init) {
+        super(init);
+    }
+    staticEvents;
+};
+ProcessorMetadata = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ProcessorMetadata);
+export { ProcessorMetadata };

package/models/metadata/variable-metadata.d.ts

@@ -0,0 +1,31 @@
+import { VariableFormat } from '../enums/variable-format.enum.js';
+import { VariableType } from '../enums/variable-type.enum.js';
+/**
+ *
+ */
+export declare class VariableMetadataRecord {
+    [key: string]: VariableMetadata;
+}
+/**
+ *
+ */
+export declare class VariableMetadata {
+    ignored?: boolean;
+    hotPlug?: boolean;
+    label?: string;
+    description?: string;
+    examples?: string[];
+    choice?: string[];
+    type?: VariableType;
+    variables?: VariableMetadataRecord;
+    format?: VariableFormat;
+    enumValues?: (string | number)[];
+    isArray?: boolean;
+    minOccurs?: number;
+    maxOccurs?: number;
+    required?: boolean;
+    default?: any;
+    pattern?: string;
+    minValue?: string | number;
+    maxValue?: string | number;
+}