@norskvideo/norsk-studio 1.0.0

package/lib/shared/document.d.ts

@@ -0,0 +1,164 @@
+import Library from "../client/library";
+import EventHandler from "eventhandler";
+import type { BaseConfig, GlobalValidation, Media, NodeInfo, SubscriptionAcceptInfo, SubscriptionProduceInfo } from "../extension/client-types";
+export type NodeDescriptionId = string;
+export type CompileIssueContext = {
+    nodeId?: string;
+    subscriptionSourceId?: string;
+} & {
+    [k: string]: unknown;
+};
+export type CompileIssue = {
+    message: string;
+    context: CompileIssueContext;
+};
+export type CompileWarning = CompileIssue;
+export type CompileError = CompileIssue;
+export type NodeEvent = {
+    id: string;
+    node: NodeDescription<BaseConfig>;
+};
+export type SubscriptionEvent = {
+    subscription: NodeSubscriptionDescription<BaseConfig>;
+    destination: NodeDescription<BaseConfig>;
+    source: NodeDescription<BaseConfig>;
+};
+export type NodeEventHandler = (e: NodeEvent) => void;
+export type SubscriptionEventHandler = (e: SubscriptionEvent) => void;
+export interface TopLevelContext {
+    addWarning: (warning: CompileWarning, ctx?: CompileIssueContext) => void;
+    addError: (error: CompileError, ctx?: CompileIssueContext) => void;
+}
+export declare class DefaultNodeValidationContext implements NodeValidationContext<BaseConfig> {
+    top: TopLevelContext;
+    document: DocumentDescription;
+    node: NodeDescription<BaseConfig>;
+    get config(): BaseConfig;
+    get subscriptions(): NodeSubscriptionDescription<BaseConfig>[];
+    constructor(top: TopLevelContext, node: NodeDescription<BaseConfig>, document: DocumentDescription);
+    videoInputs(): NodeSubscriptionDescription<BaseConfig>[];
+    audioInputs(): NodeSubscriptionDescription<BaseConfig>[];
+    requireVideo(count: number): void;
+    requireAudio(count: number): void;
+    run(): void;
+    runDefaultSubscriptionValidation(): void;
+    addWarning(message: string, ctx?: CompileIssueContext): void;
+    addError(message: string, ctx?: CompileIssueContext): void;
+}
+export declare function runGlobalValidationForRow(globalRule: GlobalValidation<BaseConfig>, currentValue: unknown | unknown[], node: NodeDescription<BaseConfig>, top: DocumentDescription): boolean | undefined;
+export interface NodeValidationContext<Config extends BaseConfig> {
+    config: Config;
+    subscriptions: NodeSubscriptionDescription<Config>[];
+    document: DocumentDescription;
+    runDefaultSubscriptionValidation: () => void;
+    addWarning: (message: string) => void;
+    addError: (message: string) => void;
+    videoInputs(): NodeSubscriptionDescription<Config>[];
+    audioInputs(): NodeSubscriptionDescription<Config>[];
+    requireVideo(count: number): void;
+    requireAudio(count: number): void;
+}
+export declare class DocumentDescription {
+    nodes: {
+        [key: NodeDescriptionId]: NodeDescription<BaseConfig>;
+    };
+    errors: CompileError[];
+    warnings: CompileWarning[];
+    layout?: {
+        [id: string]: {
+            x: number;
+            y: number;
+        };
+    };
+    globalConfig?: {
+        [key: PropertyKey]: unknown;
+    };
+    library: Library;
+    events: EventHandler;
+    constructor(library: Library, yaml?: YamlDocument);
+    forEachNode(f: (n: NodeDescription<BaseConfig>) => void): void;
+    addNode(type: string): NodeDescription<BaseConfig>;
+    removeNode(id: string): void;
+    findNode(id: string): NodeDescription<BaseConfig> | undefined;
+    getNode(id: string): NodeDescription<BaseConfig>;
+    toYaml(): YamlDocument;
+    onNodeRemoved(h: NodeEventHandler): void;
+    onNodeAdded(h: NodeEventHandler): void;
+    onNodeUpdated(h: NodeEventHandler): void;
+    onSubscriptionAdded(h: SubscriptionEventHandler): void;
+    onSubscriptionUpdated(h: SubscriptionEventHandler): void;
+    onSubscriptionRemoved(h: SubscriptionEventHandler): void;
+    handleNodeUpdate({ id, node }: {
+        id: string;
+        node: NodeDescription<BaseConfig>;
+    }): void;
+    handleNodeRemoved(_: NodeEvent): void;
+}
+export declare class NodeDescription<Config extends BaseConfig> {
+    get id(): NodeDescriptionId;
+    get type(): string;
+    get config(): Config;
+    set id(id: NodeDescriptionId);
+    set config(cfg: Config);
+    info: NodeInfo<Config>;
+    yaml: YamlNode;
+    subscribers: NodeDescriptionId[];
+    subscriptions: NodeSubscriptionDescription<Config>[];
+    document: DocumentDescription;
+    toYaml(): YamlNode;
+    constructor(document: DocumentDescription, yaml: YamlNode, info: NodeInfo<Config>);
+    removeSubscription(sourceId: string): void;
+    addSubscription<SConfig extends BaseConfig>(source: NodeDescription<SConfig>): void;
+}
+export declare class NodeSubscriptionDescription<Config extends BaseConfig> {
+    get source(): NodeDescriptionId;
+    set source(id: NodeDescriptionId);
+    get streams(): SubscriptionConfiguration;
+    set streams(config: SubscriptionConfiguration);
+    yaml: YamlSubscription;
+    node: NodeDescription<Config>;
+    document: DocumentDescription;
+    constructor(document: DocumentDescription, node: NodeDescription<Config>, yaml: YamlSubscription);
+}
+export type SubscriptionConfiguration = {
+    type: 'take-first-stream';
+    select: Media[];
+} | {
+    type: 'take-all-streams';
+    select: Media[];
+} | {
+    type: 'take-specific-streams';
+    select: Media[];
+    filter: string[];
+} | {
+    type: 'take-specific-stream';
+    select: Media[];
+    filter: string;
+};
+export declare const SubscriptionTypeInfo: {
+    [k in SubscriptionConfiguration["type"]]: string;
+};
+export declare const SubscriptionTypeDescription: {
+    [k in SubscriptionConfiguration["type"]]: string;
+};
+export type YamlDocument = {
+    app?: string;
+    nodes?: YamlNode[];
+    __globalConfig?: Record<PropertyKey, unknown>;
+    __layout?: {
+        id: string;
+        x: number;
+        y: number;
+    }[];
+};
+export type YamlNode = {
+    config?: Partial<BaseConfig> & Record<PropertyKey, unknown>;
+    type?: string;
+    subscriptions?: YamlSubscription[];
+    subscriptionValidation?: string;
+};
+export type YamlSubscription = {
+    source?: string;
+    streams?: Partial<SubscriptionConfiguration>;
+};
+export declare function buildSubscription<SC extends BaseConfig>(sourceInfo: SubscriptionProduceInfo<SC>, currentSubscriptions: NodeSubscriptionDescription<SC>[], currentCfg: SC, dest: SubscriptionAcceptInfo): SubscriptionConfiguration | undefined;

package/lib/shared/document.js

@@ -0,0 +1,496 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSubscription = exports.SubscriptionTypeDescription = exports.SubscriptionTypeInfo = exports.NodeSubscriptionDescription = exports.NodeDescription = exports.DocumentDescription = exports.runGlobalValidationForRow = exports.DefaultNodeValidationContext = void 0;
+const eventhandler_1 = __importDefault(require("eventhandler"));
+const intersect_1 = __importDefault(require("intersect"));
+const util_1 = require("./util");
+class DefaultNodeValidationContext {
+    top;
+    document;
+    node;
+    get config() {
+        return this.node.config;
+    }
+    get subscriptions() { return this.node.subscriptions; }
+    constructor(top, node, document) {
+        this.top = top;
+        this.node = node;
+        this.document = document;
+    }
+    videoInputs() {
+        return this.subscriptions.filter((s) => s.streams.select.includes("video"));
+    }
+    audioInputs() {
+        return this.subscriptions.filter((s) => s.streams.select.includes("audio"));
+    }
+    requireVideo(count) {
+        const video = this.subscriptions.filter((s) => s.streams.select.includes("video"));
+        if (video.length < count) {
+            this.addError(`${count} input video stream(s) required`);
+        }
+    }
+    requireAudio(count) {
+        const audio = this.subscriptions.filter((s) => s.streams.select.includes("video"));
+        if (audio.length < count) {
+            this.addError(`${count} input audio stream(s) required`);
+        }
+    }
+    run() {
+        if (this.node.info.validation) {
+            this.node.info.validation(this);
+        }
+        else {
+            this.runDefaultSubscriptionValidation();
+        }
+        if (this.node.info.extraValidation) {
+            this.node.info.extraValidation(this);
+        }
+        for (const [k, v] of Object.entries(this.node.info.configForm.form)) {
+            const entry = v;
+            const hintType = entry.hint.type;
+            switch (hintType) {
+                case "custom":
+                case "text":
+                case "numeric":
+                case 'list':
+                case 'form-list':
+                case "form-item":
+                case "multiselect":
+                    if (entry.hint.validation) {
+                        const result = entry.hint.validation.safeParse(this.node.config[k]);
+                        if (!result.success) {
+                            this.addError(`Validation failure on node form row ${this.node.id}:${k} - ${result.error.message}`);
+                        }
+                    }
+                    break;
+                case "boolean":
+                case "select":
+                    break;
+                default:
+                    (0, util_1.assertUnreachable)(hintType);
+            }
+            switch (hintType) {
+                case "text":
+                case "numeric":
+                case 'list':
+                case "custom":
+                    if (entry.hint.global) {
+                        const globalRule = entry.hint.global;
+                        const result = runGlobalValidationForRow(globalRule, this.node.config[k], this.node, this.document);
+                        if (result == true)
+                            break;
+                        else {
+                            if (globalRule.constraint == "custom") {
+                                this.addError(globalRule.message, { nodeId: this.node.id });
+                            }
+                            else {
+                                this.addError(`${k} must be unique`, { nodeId: this.node.id });
+                            }
+                        }
+                    }
+                    break;
+                case 'form-list':
+                case "form-item":
+                case "multiselect":
+                case "boolean":
+                case "select":
+                    break;
+                default:
+                    (0, util_1.assertUnreachable)(hintType);
+            }
+        }
+    }
+    runDefaultSubscriptionValidation() {
+        const accepts = this.node.info.subscription.accepts;
+        const acceptType = accepts?.type;
+        switch (acceptType) {
+            case undefined:
+                return;
+            case "multi-stream":
+                return;
+            case "single-stream":
+                accepts?.media.forEach((m) => {
+                    const matching = this.subscriptions.flatMap((s) => {
+                        switch (s.streams.type) {
+                            case "take-all-streams":
+                                this.addError("Invalid selector (take-all-streams) present on single-stream subscription");
+                                return [];
+                            case "take-specific-streams":
+                                this.addError("Invalid selector (take-specific streams) present on single-stream subscription");
+                                return [];
+                            case "take-first-stream":
+                                if (s.streams.select.includes(m))
+                                    return [s];
+                                return [];
+                            case "take-specific-stream":
+                                if (s.streams.select.includes(m))
+                                    return [s];
+                                return [];
+                        }
+                    });
+                    if (matching.length > 1) {
+                        this.addError("Node only accepts a single stream, but subscribes to multiple " + m + " streams");
+                    }
+                });
+                break;
+            default:
+                (0, util_1.assertUnreachable)(acceptType);
+        }
+    }
+    addWarning(message, ctx) {
+        this.top.addWarning({
+            message,
+            context: {
+                nodeId: ctx?.nodeId ?? this.node.id,
+                subscriptionSourceId: ctx?.subscriptionSourceId
+            }
+        });
+    }
+    addError(message, ctx) {
+        this.top.addError({
+            message,
+            context: {
+                nodeId: ctx?.nodeId ?? this.node.id,
+                subscriptionSourceId: ctx?.subscriptionSourceId
+            }
+        });
+    }
+}
+exports.DefaultNodeValidationContext = DefaultNodeValidationContext;
+function runGlobalValidationForRow(globalRule, currentValue, node, top) {
+    const globalConstraint = globalRule.constraint;
+    switch (globalConstraint) {
+        case "custom": {
+            return globalRule.validate(node.config, top);
+        }
+        case "unique": {
+            if (globalRule.include && !globalRule.include(node.config, top)) {
+                return undefined;
+            }
+            const matching = Object.values(top.nodes).flatMap((n) => {
+                if (n.id == node.id)
+                    return undefined;
+                return Object.entries(n.info.configForm.form).flatMap(([k, v]) => {
+                    const innerEntry = v;
+                    const innerIntType = innerEntry.hint.type;
+                    switch (innerIntType) {
+                        case "text":
+                        case "numeric":
+                        case "custom":
+                            if (innerEntry.hint.global?.constraint == "unique" && innerEntry.hint.global.key == globalRule.key) {
+                                if (innerEntry.hint.global.include && !innerEntry.hint.global.include(n.config[k], top))
+                                    return undefined;
+                                return [n.config[k]];
+                            }
+                            return undefined;
+                        case 'list':
+                            if (innerEntry.hint.global?.constraint == "unique" && innerEntry.hint.global.key == globalRule.key) {
+                                if (innerEntry.hint.global.include && !innerEntry.hint.global.include(n.config[k], top))
+                                    return undefined;
+                                return n.config[k];
+                            }
+                            return undefined;
+                        case 'form-list':
+                        case "form-item":
+                        case "multiselect":
+                        case "boolean":
+                        case "select":
+                            return undefined;
+                        default:
+                            (0, util_1.assertUnreachable)(innerIntType);
+                    }
+                });
+            }).filter((v) => v !== undefined);
+            if (currentValue instanceof Array) {
+                if (matching.some((m) => currentValue.includes(m))) {
+                    return false;
+                }
+            }
+            else {
+                if (matching.some((m) => m == currentValue)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        default:
+            (0, util_1.assertUnreachable)(globalConstraint);
+    }
+}
+exports.runGlobalValidationForRow = runGlobalValidationForRow;
+class DocumentDescription {
+    nodes = {};
+    errors;
+    warnings;
+    layout;
+    globalConfig;
+    library;
+    events;
+    constructor(library, yaml) {
+        this.errors = [];
+        this.warnings = [];
+        this.layout = undefined;
+        this.library = library;
+        this.events = new eventhandler_1.default();
+        if (yaml) {
+            if (yaml.__layout) {
+                this.layout = {};
+                for (const l of yaml.__layout) {
+                    this.layout[l.id] = l;
+                }
+            }
+            this.globalConfig = { ...yaml.__globalConfig };
+            if (yaml.nodes) {
+                for (const node of yaml.nodes) {
+                    const info = library.find(node.type ?? 'undefined');
+                    if (!info) {
+                        console.error("Failed to load node into document as type is missing", node.config?.id, node.type);
+                    }
+                    else if (!node.config?.id) {
+                        console.error("Missing id on node", node.config?.id, node.type);
+                    }
+                    else {
+                        this.nodes[node.config.id] = new NodeDescription(this, node, info);
+                    }
+                }
+            }
+        }
+        this.onNodeUpdated(this.handleNodeUpdate.bind(this));
+        this.onNodeRemoved(this.handleNodeRemoved.bind(this));
+        this.forEachNode((n) => {
+            n.subscriptions.forEach((s) => {
+                this.getNode(s.source).subscribers.push(n.id);
+            });
+        });
+    }
+    forEachNode(f) {
+        Object.values(this.nodes).forEach(f);
+    }
+    addNode(type) {
+        const info = this.library.find(type);
+        if (!info) {
+            throw new Error("Failed to find type for addition to document: " + type);
+        }
+        const node = new NodeDescription(this, { type, config: { id: '', displayName: '' }, subscriptions: [] }, info);
+        this.nodes[node.id] = node;
+        this.events.emit('onNodeAdded', { id: "", node });
+        return node;
+    }
+    removeNode(id) {
+        const existing = this.nodes[id];
+        if (existing) {
+            existing.subscriptions.forEach((s) => {
+                existing.removeSubscription(s.source);
+            });
+            existing.subscribers.forEach((s) => {
+                const subscriber = this.getNode(s);
+                subscriber.removeSubscription(id);
+            });
+            delete this.nodes[id];
+            this.events.emit('onNodeRemoved', { id, node: existing });
+        }
+    }
+    findNode(id) {
+        return this.nodes[id];
+    }
+    getNode(id) {
+        const node = this.findNode(id);
+        if (!node)
+            throw new Error("Missing node");
+        return node;
+    }
+    toYaml() {
+        return {
+            __layout: this.layout ? Object.entries(this.layout).map(([k, v]) => ({ id: k, x: v.x, y: v.y })) : [],
+            __globalConfig: this.globalConfig,
+            nodes: Object.entries(this.nodes).map(([_id, node]) => node.toYaml()),
+        };
+    }
+    onNodeRemoved(h) {
+        this.events.on('onNodeRemoved', h);
+    }
+    onNodeAdded(h) {
+        this.events.on('onNodeAdded', h);
+    }
+    onNodeUpdated(h) {
+        this.events.on('onNodeUpdated', h);
+    }
+    onSubscriptionAdded(h) {
+        this.events.on('onSubscriptionAdded', h);
+    }
+    onSubscriptionUpdated(h) {
+        this.events.on('onSubscriptionUpdated', h);
+    }
+    onSubscriptionRemoved(h) {
+        this.events.on('onSubscriptionRemoved', h);
+    }
+    handleNodeUpdate({ id, node }) {
+        if (id != node.id) {
+            delete this.nodes[id];
+            this.nodes[node.id] = node;
+            this.forEachNode((n) => {
+                n.subscriptions.forEach((s) => {
+                    if (s.source == id) {
+                        s.source = node.id;
+                    }
+                });
+                n.subscribers = n.subscribers.map((s) => {
+                    if (s == id) {
+                        return node.id;
+                    }
+                    return s;
+                });
+            });
+        }
+    }
+    handleNodeRemoved(_) {
+    }
+}
+exports.DocumentDescription = DocumentDescription;
+class NodeDescription {
+    get id() { return this.yaml.config?.id ?? ''; }
+    get type() { return this.yaml.type; }
+    get config() { return this.yaml.config; }
+    set id(id) {
+        const oldId = this.id;
+        if (this.yaml.config) {
+            this.yaml.config.id = id;
+            this.document.events.emit('onNodeUpdated', { id: oldId, node: this });
+        }
+        else {
+            console.warn("Failed to update id of node because config wasn't set yet");
+        }
+    }
+    set config(cfg) {
+        const oldId = this.id;
+        this.yaml.config = cfg;
+        this.document.events.emit('onNodeUpdated', { id: oldId, node: this });
+    }
+    info;
+    yaml;
+    subscribers = [];
+    subscriptions = [];
+    document;
+    toYaml() {
+        return this.yaml;
+    }
+    constructor(document, yaml, info) {
+        this.info = info;
+        this.yaml = yaml;
+        this.yaml.subscriptions = this.yaml.subscriptions ?? [];
+        this.document = document;
+        for (const sub of yaml.subscriptions ?? []) {
+            this.subscriptions.push(new NodeSubscriptionDescription(this.document, this, sub));
+        }
+    }
+    removeSubscription(sourceId) {
+        const sourceNode = this.document.findNode(sourceId);
+        if (sourceNode) {
+            sourceNode.subscribers = sourceNode.subscribers.filter((s) => s != this.id);
+        }
+        const existing = this.subscriptions.find((s) => s.source == sourceId);
+        if (existing) {
+            this.subscriptions = this.subscriptions.filter((s) => s.source != sourceId);
+            this.yaml.subscriptions = this.subscriptions.map((s) => s.yaml);
+            this.document.events.emit('onSubscriptionRemoved', { subscription: existing, source: sourceNode, destination: this });
+        }
+    }
+    addSubscription(source) {
+        if (!source.info.subscription.produces) {
+            console.error("Attempt to add subscription to node that doesn't produce data", source);
+            return;
+        }
+        if (!this.info.subscription.accepts) {
+            console.error("Attempt to add subscription from node that doesn't accept data", this);
+            return;
+        }
+        const streams = buildSubscription(source.info.subscription.produces, source.subscriptions, source.config, this.info.subscription.accepts);
+        if (!streams) {
+            console.error("Unable to find appropriate subscription between nodes?", source, this);
+            return;
+        }
+        source.subscribers.push(this.id);
+        const yaml = {
+            source: source.id,
+            streams
+        };
+        const subscription = new NodeSubscriptionDescription(this.document, this, yaml);
+        this.yaml.subscriptions?.push(yaml);
+        this.subscriptions.push(subscription);
+        this.document.events.emit('onSubscriptionAdded', { subscription, source, destination: this });
+    }
+}
+exports.NodeDescription = NodeDescription;
+class NodeSubscriptionDescription {
+    get source() { return this.yaml.source ?? 'unknown'; }
+    set source(id) {
+        this.yaml.source = id;
+        this.document.events.emit('onSubscriptionUpdated', { subscription: this, source: this.node, destination: this.document.nodes[this.source] });
+    }
+    get streams() { return this.yaml.streams; }
+    set streams(config) {
+        this.yaml.streams = config;
+        this.document.events.emit('onSubscriptionUpdated', { subscription: this, source: this.node, destination: this.document.nodes[this.source] });
+    }
+    yaml;
+    node;
+    document;
+    constructor(document, node, yaml) {
+        this.node = node;
+        this.yaml = yaml;
+        this.document = document;
+    }
+}
+exports.NodeSubscriptionDescription = NodeSubscriptionDescription;
+exports.SubscriptionTypeInfo = {
+    'take-all-streams': "All",
+    'take-first-stream': "First Found",
+    'take-specific-stream': "Specified Stream Only",
+    'take-specific-streams': "Specified Streams Only",
+};
+exports.SubscriptionTypeDescription = {
+    'take-all-streams': "Every stream from this source will be subscribed to",
+    'take-first-stream': "If multiple streams are available, only the first matching stream will be subscribed to",
+    'take-specific-stream': "Only the one specified stream (below) will be subscribed to",
+    'take-specific-streams': "Only the specified streams (below) will be subscribed to",
+};
+function buildSubscription(sourceInfo, currentSubscriptions, currentCfg, dest) {
+    const sourceType = sourceInfo.type;
+    const destType = dest.type;
+    switch (sourceType) {
+        case 'single-stream':
+            switch (destType) {
+                case "single-stream":
+                    return { type: 'take-first-stream', select: (0, intersect_1.default)(dest.media, sourceInfo.media) };
+                case "multi-stream":
+                    return { type: 'take-first-stream', select: (0, intersect_1.default)(dest.media, sourceInfo.media) };
+                default:
+                    return (0, util_1.assertUnreachable)(destType);
+            }
+        case "multi-stream":
+            switch (destType) {
+                case "single-stream":
+                    return { type: 'take-first-stream', select: (0, intersect_1.default)(dest.media, sourceInfo.media) };
+                case "multi-stream":
+                    return { type: 'take-all-streams', select: (0, intersect_1.default)(dest.media, sourceInfo.media) };
+                default:
+                    return (0, util_1.assertUnreachable)(destType);
+            }
+        case "fixed-list":
+            switch (destType) {
+                case "single-stream":
+                    return { type: 'take-specific-stream', select: (0, intersect_1.default)(dest.media, sourceInfo.possibleMedia), filter: sourceInfo.keys(currentCfg, currentSubscriptions)[0].key };
+                case "multi-stream":
+                    return { type: 'take-specific-streams', select: (0, intersect_1.default)(dest.media, sourceInfo.possibleMedia), filter: sourceInfo.keys(currentCfg, currentSubscriptions).map((s) => s.key) };
+                default:
+                    return (0, util_1.assertUnreachable)(destType);
+            }
+        default:
+            (0, util_1.assertUnreachable)(sourceType);
+    }
+}
+exports.buildSubscription = buildSubscription;
+//# sourceMappingURL=document.js.map