libshv-js 3.16.1 → 3.17.0

package/src/json.ts

@@ -1,136 +0,0 @@
-import {UnpackContext} from './cpcontext';
-import {CponReader, stringifyDate} from './cpon';
-import {Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt, type RpcValue} from './rpcvalue';
-
-const decodeMap = (x: object) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
-
-const decodeValueJson = (x: unknown): RpcValue => {
-    switch (true) {
-        case Array.isArray(x): {
-            const list = x as unknown[];
-            const handleType = (typeName: unknown, typeValue: unknown) => {
-                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: string): RpcValue | Error => decodeValueJson(JSON.parse(str));
-
-const JSON_TAG_META = '!shvMeta';
-const JSON_TAG_TYPE = '!shvType';
-
-const encodeValueJson = (x: RpcValue): unknown => {
-    switch (true) {
-        case x instanceof RpcValueWithMetaData: {
-            const res = [JSON_TAG_META, encodeValueJson(makeMap(x.meta))] as const;
-            const encoded = encodeValueJson(x.value);
-            if (Array.isArray(encoded) && encoded[0] === JSON_TAG_TYPE) {
-                return [...res, ...encoded as unknown[]];
-            }
-
-            return [...res, encoded];
-        }
-
-        case Array.isArray(x):
-            return x.map(value => encodeValueJson(value));
-        case isShvMap(x): {
-            const map = x as Record<string, RpcValue>;
-            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)] as const));
-        }
-
-        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: RpcValue): string | Error => JSON.stringify(encodeValueJson(value));

package/src/rpcmessage.ts

@@ -1,91 +0,0 @@
-import * as z from './zod';
-
-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_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;
-
-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,
-}
-
-const ErrorMapZod = z.imap({
-    [ERROR_CODE]: z.number(),
-    [ERROR_MESSAGE]: z.string().optional(),
-    [ERROR_DATA]: z.rpcvalue().optional(),
-});
-
-export type ErrorMap = z.infer<typeof ErrorMapZod>;
-
-const RpcRequestMetaZod = z.metamap({
-    [RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
-    [RPC_MESSAGE_REQUEST_ID]: z.number(),
-    [RPC_MESSAGE_METHOD]: z.string(),
-    [RPC_MESSAGE_SHV_PATH]: z.string(),
-    [RPC_MESSAGE_ACCESS_LEVEL]: z.int().gte(0).lte(63).optional(),
-});
-
-const RpcRequestValueZod = z.imap({
-    [RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
-}).or(z.imap({
-    [RPC_MESSAGE_ABORT]: z.boolean(),
-}));
-
-const RpcResponseMetaZod = z.metamap({
-    [RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
-    [RPC_MESSAGE_REQUEST_ID]: z.number(),
-});
-
-const RpcResponseValueZod = z.imap({
-    [RPC_MESSAGE_RESULT]: z.rpcvalue(),
-}).or(z.imap({
-    [RPC_MESSAGE_ERROR]: ErrorMapZod,
-})).or(z.imap({
-    [RPC_MESSAGE_DELAY]: z.double(),
-}));
-
-const RpcSignalMetaZod = z.metamap({
-    [RPC_MESSAGE_SHV_PATH]: z.string(),
-    [RPC_MESSAGE_METHOD]: z.string(),
-});
-const RpcSignalValueZod = z.imap({
-    [RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
-});
-
-const RpcRequestZod = z.withMeta(RpcRequestMetaZod, RpcRequestValueZod);
-const RpcResponseZod = z.withMeta(RpcResponseMetaZod, RpcResponseValueZod);
-const RpcSignalZod = z.withMeta(RpcSignalMetaZod, RpcSignalValueZod);
-const RpcMessageZod = z.union([RpcRequestZod, RpcResponseZod, RpcSignalZod]);
-export type RpcRequest = z.infer<typeof RpcRequestZod>;
-export type RpcResponse = z.infer<typeof RpcResponseZod>;
-export type RpcResponseValue = z.infer<typeof RpcResponseValueZod>;
-export type RpcSignal = z.infer<typeof RpcSignalZod>;
-export type RpcMessage = z.infer<typeof RpcMessageZod>;
-
-export const isSignal = (message: RpcMessage): message is RpcSignal => !(RPC_MESSAGE_REQUEST_ID in message.meta) && RPC_MESSAGE_METHOD in message.meta;
-export const isRequest = (message: RpcMessage): message is RpcRequest => RPC_MESSAGE_REQUEST_ID in message.meta && RPC_MESSAGE_METHOD in message.meta;
-export const isResponse = (message: RpcMessage): message is RpcResponse => RPC_MESSAGE_REQUEST_ID in message.meta && !(RPC_MESSAGE_METHOD in message.meta);
-
-export {RpcMessageZod, ErrorCode};

package/src/rpcvalue.ts

@@ -1,147 +0,0 @@
-class UInt<T extends number = number> {
-    readonly value: T;
-
-    constructor(u: T | UInt<T>) {
-        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 {
-    readonly value: number;
-
-    constructor(u: number) {
-        this.value = u;
-    }
-}
-
-class Decimal {
-    mantisa: number;
-    exponent: number;
-
-    constructor(mantisa: number, exponent: number) {
-        if (!Number.isInteger(exponent)) {
-            throw new TypeError(`Decimal: exponent must be integral (${exponent})`);
-        }
-
-        this.mantisa = mantisa;
-        this.exponent = exponent;
-    }
-}
-
-export type Null = undefined;
-export type Bool = boolean;
-export type Blob = ArrayBuffer;
-export type ShvString = string;
-export type DateTime = Date & {utc_offset?: number};
-const withOffset = (date: Date, utcOffset?: number) => {
-    const clonedDate: DateTime = new Date(date);
-    clonedDate.utc_offset = utcOffset;
-    return clonedDate;
-};
-
-export type List = RpcValue[];
-
-const shvMapType = Symbol('shvMapType');
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- I can't get rid of this yet
-type IMap<T extends Record<number, RpcValue> = Record<number, any>> = {
-    [Key in keyof T]: T[Key];
-} & {
-    [shvMapType]: 'imap';
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- I can't get rid of this yet
-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';
-};
-
-const isShvMap = (x: unknown): x is ShvMap => typeof x === 'object' && (x as ShvMap)[shvMapType] === 'map';
-
-const isIMap = (x: unknown): x is IMap => typeof x === 'object' && (x as IMap)[shvMapType] === 'imap';
-
-const isMetaMap = (x: unknown): x is IMap => typeof x === 'object' && (x as MetaMap)[shvMapType] === 'metamap';
-
-export const typeName = (x: unknown): string => {
-    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 = <T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x: U = {} as U): MetaMap<U> => ({
-    ...x,
-    [shvMapType]: 'metamap',
-});
-
-const makeIMap = <T extends Record<number, RpcValue> = Record<number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x: U = {} as U): IMap<U> => ({
-    ...x,
-    [shvMapType]: 'imap',
-});
-
-const makeMap = <T extends Record<string, RpcValue> = Record<string, RpcValue>, U extends Record<string, RpcValue> = Omit<T, typeof shvMapType>>(x: U = {} as U): ShvMap<U> => ({
-    ...x,
-    [shvMapType]: 'map',
-});
-
-class RpcValueWithMetaData<MetaSchema extends MetaMap = MetaMap, ValueSchema extends RpcValueType = RpcValueType> {
-    constructor(public meta: MetaSchema, public value: ValueSchema) {
-        /* nothing */
-    }
-}
-
-export type RpcValue = RpcValueType | RpcValueWithMetaData;
-
-export {shvMapType, Decimal, Double, type IMap, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap};