webscada-client/scada.d.ts

webSocket SCADA communication client components

import "./style.css";
declare global {
    interface Array<T> {
        includes(v: T): boolean;
        remove(v: T): boolean;
    }
    interface Window {
        plc: any;
    }
}
type Simpletype = string | number | Date | boolean;
type DT<T extends Simpletype> = [string] | [string, T] | [string, T, number];
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type TagsDefine = {
    [k: string]: {
        addr?: string;
        tags: {
            [k: string]: DT<any>;
        };
    };
};
type TagsProperty<T extends TagsDefine> = UnionToIntersection<T[keyof T]["tags"]>;
type TagNames<T extends TagsDefine> = keyof TagsProperty<T>;
type TagValues<T extends TagsDefine, K extends TagNames<T>> = Exclude<TagsProperty<T>[K][1 & keyof TagsProperty<T>[K]], undefined>;
type NumberFilter<T extends TagsDefine, M extends TagNames<T>> = TagValues<T, M> extends number ? M : never;
type Tags<T extends TagsDefine> = {
    [k in TagNames<T>]: TagValues<T, k>;
} & {
    [k in TagNames<T> as `${string & k}_Quality`]: number;
} & {
    [k in TagNames<T> as `${string & k}_TimeStamp`]: number;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_Precision`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit0`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit1`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit2`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit3`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit4`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit5`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit6`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit7`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit8`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit9`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit10`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit11`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit12`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit13`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit14`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit15`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit16`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit17`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit18`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit19`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit20`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit21`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit22`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit23`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit24`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit25`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit26`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit27`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit28`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit29`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit30`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit31`]: 0 | 1;
} & {
    [k in TagNames<T> as `${string & NumberFilter<T, k>}_bit32`]: 0 | 1;
};
type TagsTag<T extends TagsDefine> = {
    [k: string]: PLCTag<T>;
};
type TagChangeEventType<T extends TagsDefine> = (tag: Tags<T>) => boolean | (0 | 1);
interface PLCEvent<T> {
    sender?: T;
    type?: string;
    equipmentName?: string;
    equipmentAddr?: string;
}
interface TagChangeEventParam<T extends TagsDefine> {
    sender: PLCTag<T>;
    type: string;
    tagName: string;
    tagAddr?: string;
    devValue: any;
    tagValue: any;
}
interface PLCErrorEvent<T> extends PLCEvent<T> {
    code: number;
    msg: string;
}
interface PLCEventMap<T> {
    error: PLCErrorEvent<T>;
    open: PLCEvent<T>;
}
type PLCEventType<T extends TagsDefine> = keyof PLCEventMap<any> | TagNames<T> | TagNames<T>[] | TagChangeEventType<T>;
type TFEvent<T extends TagsDefine, This, SCOPE> = {
    onTrue(this: unknown extends SCOPE ? This : SCOPE, e: TagChangeEventParam<T>): void;
    onTrueDelay?: number;
    onTrueInterval?: number;
    onFalse?(this: unknown extends SCOPE ? This : SCOPE, e: TagChangeEventParam<T>): void;
    onFalseDelay?: number;
    onFalseInterval?: number;
};
type FTEvent<T extends TagsDefine, This, SCOPE> = {
    onTrue?(this: unknown extends SCOPE ? This : SCOPE, e: TagChangeEventParam<T>): void;
    onTrueDelay?: number;
    onTrueInterval?: number;
    onFalse(this: unknown extends SCOPE ? This : SCOPE, e: TagChangeEventParam<T>): void;
    onFalseDelay?: number;
    onFalseInterval?: number;
};
interface Node {
    [k: string]: any;
}
declare class PLCTag<T extends TagsDefine> {
    private maddr?;
    private mname;
    private mvalue;
    private mdevValue?;
    private mprecision?;
    private mquality?;
    private mtimeStamp?;
    private mactive;
    private mevents;
    private mhotPoints;
    private mplc;
    private meqp?;
    constructor(plc: AppHandler<T>, tagname: string, value?: Simpletype, eqp?: Equipment<T>, addr?: string);
    private notify;
    removeHotPoint(hotPoint: HotPoint): void;
    set value(v: Simpletype);
    get value(): Simpletype;
    set active(v: boolean);
    private on;
    private fire;
}
declare class Equipment<T extends TagsDefine> {
    private mWebSocket;
    private maddr;
    private mname;
    private mtags;
    private mplc;
    status: "closed" | "connecting" | "opened";
    private doOpen;
    private onWSOpen;
    private onWSError;
    private onWSClose;
    private decodeMsg;
    private registTags;
    private unload;
    private bind_unload;
    private open;
    protected writeTag: (addr: string, value: any) => void;
    constructor(plc: AppHandler<T>, tags: T[keyof T], name: string, autoOpen: boolean);
}
declare class AppHandler<T extends TagsDefine> {
    static mutationsCollector: MutationCollector;
    tags: TagsTag<T>;
    private mevents;
    private mequipments;
    open(): void;
    private defineProperty;
    constructor(tags: T, autoOpen?: boolean);
    on<K extends PLCEventType<T>, SCOPE>(type: K, callback: K extends TagChangeEventType<T> ? TFEvent<T, this, SCOPE> | FTEvent<T, this, SCOPE> : (this: unknown extends SCOPE ? this : SCOPE, e: K extends keyof PLCEventMap<this> ? PLCEventMap<this>[K] : TagChangeEventParam<T>) => void, once?: boolean, scope?: SCOPE): void;
    private fire;
    private registrationHotpoint;
}
interface HotPoint {
    node: Node;
    attributeName1: string;
    attributeName2?: string;
    oldValue: string;
    notifier: Set<PLCTag<any>>;
    activate: boolean;
}
declare class MutationCollector {
    private regStyle;
    private regStyleName;
    private regProperty;
    private regFullProperty;
    private mreciver;
    private mhotPoints;
    private mobserver;
    private mobserverOption;
    private oldRecords?;
    get hotPoints(): HotPoint[];
    private removeHotPoint;
    private addHotPoint;
    attachReciver(reciver: AppHandler<any>): void;
    private praseProperty;
    start(): void;
    stop(): void;
    private processedNodes;
    private timer;
    private recursiveAddNode;
    private recursiveRemoveNode;
    private documentChange;
    constructor();
}
type Plc = new <T extends TagsDefine>(tags: T, autoOpen?: boolean) => Tags<T> & AppHandler<T>;
declare let Plc: Plc;
declare type PLC<T extends TagsDefine> = Tags<T> & AppHandler<T>;
export { DT, Plc, PLC };