libshv-js 3.9.0 → 3.9.2

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './access';
+export * from './chainpack';
+export * from './cpcontext';
+export * from './cpon';
+export * from './json';
+export * from './rpcmessage';
+export * from './rpcvalue';
+export * from './ws-client';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './access';
+export * from './chainpack';
+export * from './cpcontext';
+export * from './cpon';
+export * from './json';
+export * from './rpcmessage';
+export * from './rpcvalue';
+export * from './ws-client';

package/dist/json.d.ts

@@ -0,0 +1,3 @@
+import { type RpcValue } from './rpcvalue';
+export declare const fromJson: (str: string) => RpcValue | Error;
+export declare const toJson: (value: RpcValue) => string | Error;

package/dist/json.js

@@ -0,0 +1,113 @@
+import { UnpackContext } from './cpcontext';
+import { CponReader, stringifyDate } from './cpon';
+import { Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt } from './rpcvalue';
+const decodeMap = (x) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
+const decodeValueJson = (x) => {
+    switch (true) {
+        case Array.isArray(x): {
+            const list = x;
+            const handleType = (typeName, typeValue) => {
+                switch (true) {
+                    case typeName === 'Blob': {
+                        if (typeof typeValue !== 'string' || typeValue.length % 2 !== 0) {
+                            throw new TypeError(`Invalid JSON-encoded Blob: '${JSON.stringify(typeValue)}'`);
+                        }
+                        const buffer = new ArrayBuffer(typeValue.length / 2);
+                        const array = new Uint8Array(buffer);
+                        // I can assume even length because of the previous check.
+                        for (let i = 0; i < typeValue.length / 2; i++) {
+                            array[i] = Number.parseInt(typeValue.slice(i * 2, (i * 2) + 2), 16);
+                        }
+                        return buffer;
+                    }
+                    case typeName === 'IMap':
+                        if (typeof typeValue !== 'object' || typeValue === null) {
+                            throw new TypeError(`Invalid JSON-encoded IMap: '${JSON.stringify(typeValue)}'`);
+                        }
+                        if (Object.keys(typeValue).some(key => !/^-?\d+$/.test(key))) {
+                            throw new TypeError(`Invalid JSON-encoded IMap (non-Int key): '${JSON.stringify(typeValue)}'`);
+                        }
+                        return makeIMap(decodeMap(typeValue));
+                    case typeName === 'DateTime':
+                        if (typeof typeValue !== 'string') {
+                            throw new TypeError(`Invalid JSON-encoded DateTime: '${JSON.stringify(typeValue)}'`);
+                        }
+                        // Kinda lame that I'm encoding the datetime string, but this is the easiest way right now.
+                        return new CponReader(new UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
+                    default:
+                        throw new TypeError(`Invalid JSON-encoded type name: '${JSON.stringify(typeName)}'`);
+                }
+            };
+            switch (true) {
+                case list.length === 3 && list[0] === JSON_TAG_TYPE:
+                    return handleType(list[1], list[2]);
+                case list.length === 3 && list[0] === JSON_TAG_META:
+                case list.length === 5 && list[0] === JSON_TAG_META && list[2] === JSON_TAG_TYPE: {
+                    if (typeof list[1] !== 'object' || list[1] === null) {
+                        throw new TypeError(`Invalid JSON-encoded MetaData: '${JSON.stringify(list[1])}'`);
+                    }
+                    const value = (() => {
+                        if (list.length === 3) {
+                            const decoded = decodeValueJson(list[2]);
+                            if (decoded instanceof RpcValueWithMetaData) {
+                                throw new TypeError('Logic error: got RpcValueWithMetaData as the value in JSON-encoded RpcValueWithMetaData, please report this bug to the maintainer.');
+                            }
+                            return decoded;
+                        }
+                        return handleType(list[3], list[4]);
+                    })();
+                    return new RpcValueWithMetaData(makeMetaMap(decodeMap(list[1])), value);
+                }
+                default:
+                    return list.map(value => decodeValueJson(value));
+            }
+        }
+        case x === null:
+            return undefined;
+        case typeof x === 'object':
+            return decodeMap(x);
+        case typeof x === 'number':
+        case typeof x === 'boolean':
+        case typeof x === 'string':
+            return x;
+        default:
+            throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
+    }
+};
+export const fromJson = (str) => decodeValueJson(JSON.parse(str));
+const JSON_TAG_META = '!shvMeta';
+const JSON_TAG_TYPE = '!shvType';
+const encodeValueJson = (x) => {
+    switch (true) {
+        case x instanceof RpcValueWithMetaData: {
+            const res = [JSON_TAG_META, encodeValueJson(makeMap(x.meta))];
+            const encoded = encodeValueJson(x.value);
+            if (Array.isArray(encoded) && encoded[0] === JSON_TAG_TYPE) {
+                return [...res, ...encoded];
+            }
+            return [...res, encoded];
+        }
+        case Array.isArray(x):
+            return x.map(value => encodeValueJson(value));
+        case isShvMap(x): {
+            const map = x;
+            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)]));
+        }
+        case isIMap(x):
+            return [JSON_TAG_TYPE, 'IMap', encodeValueJson(makeMap(x))];
+        case x instanceof ArrayBuffer:
+            return [JSON_TAG_TYPE, 'Blob', new Uint8Array(x).reduce((acc, v) => acc + v.toString(16).padStart(2, '0'), '')];
+        case x instanceof Date:
+            return [JSON_TAG_TYPE, 'DateTime', stringifyDate(x)];
+        case x === undefined:
+            // eslint-disable-next-line unicorn/no-null
+            return null;
+        case x instanceof Decimal:
+        case x instanceof UInt:
+        case x instanceof Double:
+            throw new TypeError('Decimal/Double/UInt not supported in JSON');
+        default:
+            return x;
+    }
+};
+export const toJson = (value) => JSON.stringify(encodeValueJson(value));

package/dist/rpcmessage.d.ts

@@ -0,0 +1,73 @@
+import { Double, IMap, MetaMap, RpcValue, type RpcValueWithMetaData } from './rpcvalue';
+export declare const RPC_MESSAGE_REQUEST_ID = 8;
+export declare const RPC_MESSAGE_SHV_PATH = 9;
+export declare const RPC_MESSAGE_METHOD = 10;
+export declare const RPC_MESSAGE_CALLER_IDS = 11;
+export declare const RPC_MESSAGE_USER_ID = 16;
+export declare const RPC_MESSAGE_ACCESS_LEVEL = 17;
+export declare const RPC_MESSAGE_PARAMS = 1;
+export declare const RPC_MESSAGE_RESULT = 2;
+export declare const RPC_MESSAGE_ERROR = 3;
+export declare const RPC_MESSAGE_DELAY = 4;
+export declare const RPC_MESSAGE_ABORT = 5;
+export declare const ERROR_CODE = 1;
+export declare const ERROR_MESSAGE = 2;
+export declare const ERROR_DATA = 3;
+export declare enum ErrorCode {
+    InvalidRequest = 1,
+    MethodNotFound = 2,
+    InvalidParams = 3,
+    InternalError = 4,
+    ParseError = 5,
+    MethodCallTimeout = 6,
+    MethodCallCancelled = 7,
+    MethodCallException = 8,
+    Unknown = 9,
+    LoginRequired = 10,
+    UserIDRequired = 11,
+    NotImplemented = 12
+}
+export type ErrorMap = IMap<{
+    [ERROR_CODE]: number;
+    [ERROR_MESSAGE]?: string | undefined;
+    [ERROR_DATA]?: RpcValue;
+}>;
+type RpcRequestMeta = MetaMap<{
+    [RPC_MESSAGE_REQUEST_ID]: number;
+    [RPC_MESSAGE_SHV_PATH]: string;
+    [RPC_MESSAGE_METHOD]: string;
+    [RPC_MESSAGE_CALLER_IDS]?: number | number[] | undefined;
+    [RPC_MESSAGE_USER_ID]?: string | undefined;
+    [RPC_MESSAGE_ACCESS_LEVEL]?: number | undefined;
+}>;
+type RpcRequestValue = IMap<{
+    [RPC_MESSAGE_PARAMS]?: RpcValue;
+}> | IMap<{
+    [RPC_MESSAGE_ABORT]: boolean;
+}>;
+export type RpcRequest = RpcValueWithMetaData<RpcRequestMeta, RpcRequestValue>;
+type RpcResponseMeta = MetaMap<{
+    [RPC_MESSAGE_REQUEST_ID]: number;
+    [RPC_MESSAGE_CALLER_IDS]?: number | number[] | undefined;
+}>;
+export type RpcResponseValue = IMap<{
+    [RPC_MESSAGE_RESULT]: RpcValue;
+}> | IMap<{
+    [RPC_MESSAGE_ERROR]: ErrorMap;
+}> | IMap<{
+    [RPC_MESSAGE_DELAY]: Double;
+}>;
+export type RpcResponse = RpcValueWithMetaData<RpcResponseMeta, RpcResponseValue>;
+type RpcSignalMeta = MetaMap<{
+    [RPC_MESSAGE_SHV_PATH]: string;
+    [RPC_MESSAGE_METHOD]: string;
+}>;
+type RpcSignalValue = IMap<{
+    [RPC_MESSAGE_PARAMS]?: RpcValue;
+}>;
+export type RpcSignal = RpcValueWithMetaData<RpcSignalMeta, RpcSignalValue>;
+export type RpcMessage = RpcRequest | RpcResponse | RpcSignal;
+export declare const isSignal: (message: unknown) => message is RpcSignal;
+export declare const isRequest: (message: unknown) => message is RpcRequest;
+export declare const isResponse: (message: unknown) => message is RpcResponse;
+export {};

package/dist/rpcmessage.js

@@ -0,0 +1,37 @@
+export const RPC_MESSAGE_REQUEST_ID = 8;
+export const RPC_MESSAGE_SHV_PATH = 9;
+export const RPC_MESSAGE_METHOD = 10;
+export const RPC_MESSAGE_CALLER_IDS = 11;
+export const RPC_MESSAGE_USER_ID = 16;
+export const RPC_MESSAGE_ACCESS_LEVEL = 17;
+export const RPC_MESSAGE_PARAMS = 1;
+export const RPC_MESSAGE_RESULT = 2;
+export const RPC_MESSAGE_ERROR = 3;
+export const RPC_MESSAGE_DELAY = 4;
+export const RPC_MESSAGE_ABORT = 5;
+export const ERROR_CODE = 1;
+export const ERROR_MESSAGE = 2;
+export const ERROR_DATA = 3;
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["InvalidRequest"] = 1] = "InvalidRequest";
+    ErrorCode[ErrorCode["MethodNotFound"] = 2] = "MethodNotFound";
+    ErrorCode[ErrorCode["InvalidParams"] = 3] = "InvalidParams";
+    ErrorCode[ErrorCode["InternalError"] = 4] = "InternalError";
+    ErrorCode[ErrorCode["ParseError"] = 5] = "ParseError";
+    ErrorCode[ErrorCode["MethodCallTimeout"] = 6] = "MethodCallTimeout";
+    ErrorCode[ErrorCode["MethodCallCancelled"] = 7] = "MethodCallCancelled";
+    ErrorCode[ErrorCode["MethodCallException"] = 8] = "MethodCallException";
+    ErrorCode[ErrorCode["Unknown"] = 9] = "Unknown";
+    ErrorCode[ErrorCode["LoginRequired"] = 10] = "LoginRequired";
+    ErrorCode[ErrorCode["UserIDRequired"] = 11] = "UserIDRequired";
+    ErrorCode[ErrorCode["NotImplemented"] = 12] = "NotImplemented";
+})(ErrorCode || (ErrorCode = {}));
+const implRpcMessage = (message) => typeof message === 'object'
+    && message !== null
+    && 'meta' in message
+    && typeof message.meta === 'object'
+    && message.meta !== null;
+export const isSignal = (message) => implRpcMessage(message) && !(RPC_MESSAGE_REQUEST_ID in message.meta) && RPC_MESSAGE_METHOD in message.meta;
+export const isRequest = (message) => implRpcMessage(message) && RPC_MESSAGE_REQUEST_ID in message.meta && RPC_MESSAGE_METHOD in message.meta;
+export const isResponse = (message) => implRpcMessage(message) && RPC_MESSAGE_REQUEST_ID in message.meta && !(RPC_MESSAGE_METHOD in message.meta);

package/dist/rpcvalue.d.ts

@@ -0,0 +1,56 @@
+declare class UInt<T extends number = number> {
+    readonly value: T;
+    constructor(u: T | UInt<T>);
+    [Symbol.toPrimitive](): T;
+    toString(): string;
+}
+declare class Double {
+    readonly value: number;
+    constructor(u: number);
+}
+declare class Decimal {
+    mantisa: number;
+    exponent: number;
+    constructor(mantisa: number, exponent: number);
+}
+export type Null = undefined;
+export type Bool = boolean;
+export type Blob = ArrayBuffer;
+export type ShvString = string;
+export type DateTime = Date & {
+    utc_offset?: number;
+};
+declare const withOffset: (date: Date, utcOffset?: number) => DateTime;
+export type List = RpcValue[];
+declare const shvMapType: unique symbol;
+type IMap<T extends Record<number, RpcValue> = Record<number, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'imap';
+};
+type ShvMap<T extends Record<string, RpcValue> = Record<string, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'map';
+};
+export type Int = number;
+export type RpcValueType = Null | Bool | Int | UInt | Double | Decimal | Blob | ShvString | DateTime | List | ShvMap | IMap;
+type MetaMap<T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'metamap';
+};
+declare const isShvMap: (x: unknown) => x is ShvMap;
+declare const isIMap: (x: unknown) => x is IMap;
+declare const isMetaMap: (x: unknown) => x is IMap;
+export declare const typeName: (x: unknown) => string;
+declare const makeMetaMap: <T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => MetaMap<U>;
+declare const makeIMap: <T extends Record<number, RpcValue> = Record<number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => IMap<U>;
+declare const makeMap: <T extends Record<string, RpcValue> = Record<string, RpcValue>, U extends Record<string, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => ShvMap<U>;
+declare class RpcValueWithMetaData<MetaSchema extends MetaMap = MetaMap, ValueSchema extends RpcValueType = RpcValueType> {
+    meta: MetaSchema;
+    value: ValueSchema;
+    constructor(meta: MetaSchema, value: ValueSchema);
+}
+export type RpcValue = RpcValueType | RpcValueWithMetaData;
+export { shvMapType, Decimal, Double, type IMap, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap };

package/dist/rpcvalue.js

@@ -0,0 +1,85 @@
+class UInt {
+    value;
+    constructor(u) {
+        if (u instanceof UInt) {
+            this.value = u.value;
+            return;
+        }
+        if (u < 0 || !Number.isInteger(u)) {
+            throw new Error(`Invalid value '${u}' for UInt must a positive integral number`);
+        }
+        this.value = u;
+    }
+    [Symbol.toPrimitive]() {
+        return this.value;
+    }
+    toString() {
+        return `${this.value.toString()}`;
+    }
+}
+class Double {
+    value;
+    constructor(u) {
+        this.value = u;
+    }
+}
+class Decimal {
+    mantisa;
+    exponent;
+    constructor(mantisa, exponent) {
+        if (!Number.isInteger(exponent)) {
+            throw new TypeError(`Decimal: exponent must be integral (${exponent})`);
+        }
+        this.mantisa = mantisa;
+        this.exponent = exponent;
+    }
+}
+const withOffset = (date, utcOffset) => {
+    const clonedDate = new Date(date);
+    clonedDate.utc_offset = utcOffset;
+    return clonedDate;
+};
+const shvMapType = Symbol('shvMapType');
+const isShvMap = (x) => typeof x === 'object' && x[shvMapType] === 'map';
+const isIMap = (x) => typeof x === 'object' && x[shvMapType] === 'imap';
+const isMetaMap = (x) => typeof x === 'object' && x[shvMapType] === 'metamap';
+export const typeName = (x) => {
+    switch (true) {
+        case x === undefined: return 'Null';
+        case typeof x === 'boolean': return 'Bool';
+        case typeof x === 'string': return 'String';
+        case x instanceof ArrayBuffer: return 'Blob';
+        case x instanceof UInt: return 'UInt';
+        case typeof x === 'number': return 'Int';
+        case x instanceof Double: return 'Double';
+        case x instanceof Decimal: return 'Decimal';
+        case Array.isArray(x): return 'List';
+        case x instanceof Date: return 'Date';
+        case isShvMap(x): return 'ShvMap';
+        case isIMap(x): return 'IMap';
+        case isMetaMap(x): return 'MetaMap';
+        default: return '<unknown type>';
+    }
+};
+const makeMetaMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'metamap',
+});
+const makeIMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'imap',
+});
+const makeMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'map',
+});
+class RpcValueWithMetaData {
+    meta;
+    value;
+    constructor(meta, value) {
+        this.meta = meta;
+        this.value = value;
+        /* nothing */
+    }
+}
+export { shvMapType, Decimal, Double, RpcValueWithMetaData, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap };

package/dist/shv-ri.d.ts

@@ -0,0 +1,12 @@
+export declare class ShvRI {
+    private ri;
+    private methodSepIx;
+    private signalSepIx?;
+    constructor(ri: string);
+    path(): string;
+    method(): string;
+    signal(): string | undefined;
+    hasSignal(): boolean;
+    asString(): string;
+    static fromPathMethodSignal(path: string, method: string, signal?: string): ShvRI;
+}

package/dist/shv-ri.js

@@ -0,0 +1,51 @@
+export class ShvRI {
+    ri;
+    methodSepIx;
+    signalSepIx;
+    constructor(ri) {
+        const methodSepIx = ri.indexOf(':');
+        if (methodSepIx === -1) {
+            throw new Error('Method separator ":" is missing.');
+        }
+        const signalSepRelative = ri.indexOf(':', methodSepIx + 1);
+        const signalSepIx = signalSepRelative !== -1 ? signalSepRelative : undefined;
+        this.ri = ri;
+        this.methodSepIx = methodSepIx;
+        this.signalSepIx = signalSepIx;
+        const method = this.method();
+        if (method.length === 0) {
+            throw new Error('Method must not be empty.');
+        }
+        const signal = this.signal();
+        if (signal?.length === 0) {
+            throw new Error('Signal, if present, must not be empty.');
+        }
+    }
+    path() {
+        return this.ri.slice(0, this.methodSepIx);
+    }
+    method() {
+        if (this.signalSepIx !== undefined) {
+            return this.ri.slice(this.methodSepIx + 1, this.signalSepIx);
+        }
+        return this.ri.slice(this.methodSepIx + 1);
+    }
+    signal() {
+        if (this.signalSepIx !== undefined) {
+            return this.ri.slice(this.signalSepIx + 1);
+        }
+    }
+    hasSignal() {
+        return this.signalSepIx !== undefined;
+    }
+    asString() {
+        return this.ri;
+    }
+    static fromPathMethodSignal(path, method, signal) {
+        const m = method.length === 0 ? '*' : method;
+        const ri = signal !== undefined
+            ? `${path}:${m}:${signal}`
+            : `${path}:${m}`;
+        return new ShvRI(ri);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export type StringGetter = string | Promise<string> | (() => string | Promise<string>);
+export declare const resolveString: (input: StringGetter) => string | Promise<string>;

package/dist/utils.js

@@ -0,0 +1,6 @@
+export const resolveString = (input) => {
+    if (typeof input === 'function') {
+        input = input();
+    }
+    return input;
+};