libshv-js 7.1.13 → 8.0.0

package/dist/json.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toJson = exports.fromJson = void 0;
-const cpcontext_1 = require("./cpcontext");
-const cpon_1 = require("./cpon");
-const rpcvalue_1 = require("./rpcvalue");
+import { UnpackContext } from './cpcontext.js';
+import { CponReader, stringifyDate } from './cpon.js';
+import { Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt } from './rpcvalue.js';
 // eslint-disable-next-line @typescript-eslint/no-restricted-types
-const decodeMap = (x) => (0, rpcvalue_1.makeMap)(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
+const decodeMap = (x) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
 const decodeValueJson = (x) => {
     switch (true) {
         case Array.isArray(x): {
@@ -31,13 +28,13 @@ const decodeValueJson = (x) => {
                         if (Object.keys(typeValue).some(key => !/^-?\d+$/v.test(key))) {
                             throw new TypeError(`Invalid JSON-encoded IMap (non-Int key): '${JSON.stringify(typeValue)}'`);
                         }
-                        return (0, rpcvalue_1.makeIMap)(decodeMap(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 cpon_1.CponReader(new cpcontext_1.UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
+                        return new CponReader(new UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
                     default:
                         throw new TypeError(`Invalid JSON-encoded type name: '${JSON.stringify(typeName)}'`);
                 }
@@ -53,14 +50,14 @@ const decodeValueJson = (x) => {
                     const value = (() => {
                         if (list.length === 3) {
                             const decoded = decodeValueJson(list[2]);
-                            if (decoded instanceof rpcvalue_1.RpcValueWithMetaData) {
+                            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 rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)(decodeMap(list[1])), value);
+                    return new RpcValueWithMetaData(makeMetaMap(decodeMap(list[1])), value);
                 }
                 default:
                     return list.map(value => decodeValueJson(value));
@@ -78,14 +75,13 @@ const decodeValueJson = (x) => {
             throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
     }
 };
-const fromJson = (str) => decodeValueJson(JSON.parse(str));
-exports.fromJson = fromJson;
+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 rpcvalue_1.RpcValueWithMetaData: {
-            const res = [JSON_TAG_META, encodeValueJson((0, rpcvalue_1.makeMap)(x.meta))];
+        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];
@@ -94,25 +90,24 @@ const encodeValueJson = (x) => {
         }
         case Array.isArray(x):
             return x.map(value => encodeValueJson(value));
-        case (0, rpcvalue_1.isShvMap)(x): {
+        case isShvMap(x): {
             const map = x;
             return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)]));
         }
-        case (0, rpcvalue_1.isIMap)(x):
-            return [JSON_TAG_TYPE, 'IMap', encodeValueJson((0, rpcvalue_1.makeMap)(x))];
+        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', (0, cpon_1.stringifyDate)(x)];
+            return [JSON_TAG_TYPE, 'DateTime', stringifyDate(x)];
         case x === undefined:
             return null;
-        case x instanceof rpcvalue_1.Decimal:
-        case x instanceof rpcvalue_1.UInt:
-        case x instanceof rpcvalue_1.Double:
+        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;
     }
 };
-const toJson = (value) => JSON.stringify(encodeValueJson(value));
-exports.toJson = toJson;
+export const toJson = (value) => JSON.stringify(encodeValueJson(value));

package/dist/rpcmessage.d.ts

@@ -1,4 +1,4 @@
-import { type Double, type IMap, type MetaMap, type RpcValue, type RpcValueWithMetaData } from './rpcvalue';
+import { type Double, type IMap, type MetaMap, type RpcValue, type RpcValueWithMetaData } from './rpcvalue.js';
 export declare const RPC_MESSAGE_REQUEST_ID = 8;
 export declare const RPC_MESSAGE_SHV_PATH = 9;
 export declare const RPC_MESSAGE_METHOD = 10;

package/dist/rpcmessage.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isResponse = exports.isRequest = exports.isSignal = exports.ErrorCode = exports.ERROR_DATA = exports.ERROR_MESSAGE = exports.ERROR_CODE = exports.RPC_MESSAGE_ABORT = exports.RPC_MESSAGE_DELAY = exports.RPC_MESSAGE_ERROR = exports.RPC_MESSAGE_RESULT = exports.RPC_MESSAGE_PARAMS = exports.RPC_MESSAGE_ACCESS_LEVEL = exports.RPC_MESSAGE_USER_ID = exports.RPC_MESSAGE_CALLER_IDS = exports.RPC_MESSAGE_METHOD = exports.RPC_MESSAGE_SHV_PATH = exports.RPC_MESSAGE_REQUEST_ID = void 0;
-exports.RPC_MESSAGE_REQUEST_ID = 8;
-exports.RPC_MESSAGE_SHV_PATH = 9;
-exports.RPC_MESSAGE_METHOD = 10;
-exports.RPC_MESSAGE_CALLER_IDS = 11;
-exports.RPC_MESSAGE_USER_ID = 16;
-exports.RPC_MESSAGE_ACCESS_LEVEL = 17;
-exports.RPC_MESSAGE_PARAMS = 1;
-exports.RPC_MESSAGE_RESULT = 2;
-exports.RPC_MESSAGE_ERROR = 3;
-exports.RPC_MESSAGE_DELAY = 4;
-exports.RPC_MESSAGE_ABORT = 5;
-exports.ERROR_CODE = 1;
-exports.ERROR_MESSAGE = 2;
-exports.ERROR_DATA = 3;
-var ErrorCode;
+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";
@@ -29,15 +26,12 @@ var ErrorCode;
     ErrorCode[ErrorCode["LoginRequired"] = 10] = "LoginRequired";
     ErrorCode[ErrorCode["UserIDRequired"] = 11] = "UserIDRequired";
     ErrorCode[ErrorCode["NotImplemented"] = 12] = "NotImplemented";
-})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+})(ErrorCode || (ErrorCode = {}));
 const implRpcMessage = (message) => typeof message === 'object'
     && message !== null
     && 'meta' in message
     && typeof message.meta === 'object'
     && message.meta !== null;
-const isSignal = (message) => implRpcMessage(message) && !Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
-exports.isSignal = isSignal;
-const isRequest = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
-exports.isRequest = isRequest;
-const isResponse = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, exports.RPC_MESSAGE_REQUEST_ID) && !Object.hasOwn(message.meta, exports.RPC_MESSAGE_METHOD);
-exports.isResponse = isResponse;
+export const isSignal = (message) => implRpcMessage(message) && !Object.hasOwn(message.meta, RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, RPC_MESSAGE_METHOD);
+export const isRequest = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, RPC_MESSAGE_REQUEST_ID) && Object.hasOwn(message.meta, RPC_MESSAGE_METHOD);
+export const isResponse = (message) => implRpcMessage(message) && Object.hasOwn(message.meta, RPC_MESSAGE_REQUEST_ID) && !Object.hasOwn(message.meta, RPC_MESSAGE_METHOD);

package/dist/rpcvalue.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isShvMap = exports.isMetaMap = exports.isIMap = exports.makeMetaMap = exports.makeIMap = exports.makeMap = exports.withOffset = exports.UInt = exports.RpcValueWithMetaData = exports.Double = exports.Decimal = exports.shvMapType = exports.typeName = void 0;
 class UInt {
     value;
     constructor(u) {
@@ -20,14 +17,12 @@ class UInt {
         return this.value.toString();
     }
 }
-exports.UInt = UInt;
 class Double {
     value;
     constructor(u) {
         this.value = u;
     }
 }
-exports.Double = Double;
 class Decimal {
     mantisa;
     exponent;
@@ -39,22 +34,16 @@ class Decimal {
         this.exponent = exponent;
     }
 }
-exports.Decimal = Decimal;
 const withOffset = (date, utcOffset) => {
     const clonedDate = new Date(date);
     clonedDate.utc_offset = utcOffset;
     return clonedDate;
 };
-exports.withOffset = withOffset;
 const shvMapType = Symbol('shvMapType');
-exports.shvMapType = shvMapType;
 const isShvMap = (x) => typeof x === 'object' && x[shvMapType] === 'map';
-exports.isShvMap = isShvMap;
 const isIMap = (x) => typeof x === 'object' && x[shvMapType] === 'imap';
-exports.isIMap = isIMap;
 const isMetaMap = (x) => typeof x === 'object' && x[shvMapType] === 'metamap';
-exports.isMetaMap = isMetaMap;
-const typeName = (x) => {
+export const typeName = (x) => {
     switch (true) {
         case x === undefined: return 'Null';
         case typeof x === 'boolean': return 'Bool';
@@ -72,22 +61,18 @@ const typeName = (x) => {
         default: return '<unknown type>';
     }
 };
-exports.typeName = typeName;
 const makeMetaMap = (x = {}) => ({
     ...x,
     [shvMapType]: 'metamap',
 });
-exports.makeMetaMap = makeMetaMap;
 const makeIMap = (x = {}) => ({
     ...x,
     [shvMapType]: 'imap',
 });
-exports.makeIMap = makeIMap;
 const makeMap = (x = {}) => ({
     ...x,
     [shvMapType]: 'map',
 });
-exports.makeMap = makeMap;
 class RpcValueWithMetaData {
     meta;
     value;
@@ -97,4 +82,4 @@ class RpcValueWithMetaData {
         // nothing
     }
 }
-exports.RpcValueWithMetaData = RpcValueWithMetaData;
+export { shvMapType, Decimal, Double, RpcValueWithMetaData, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap };

package/dist/shv-ri.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShvRI = void 0;
-class ShvRI {
+export class ShvRI {
     static fromPathMethodSignal(path, method, signal) {
         const m = method.length === 0 ? '*' : method;
         const ri = signal !== undefined
@@ -52,4 +49,3 @@ class ShvRI {
         return this.ri;
     }
 }
-exports.ShvRI = ShvRI;

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { type ShvRI } from './shv-ri';
+import { type ShvRI } from './shv-ri.js';
 export type StringGetter = string | Promise<string> | (() => string | Promise<string>);
 export declare const resolveString: (input: StringGetter) => string | Promise<string>;
 export type RIGetter = ShvRI | Promise<ShvRI> | (() => ShvRI | Promise<ShvRI>);

package/dist/utils.js

@@ -1,17 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRI = exports.resolveString = void 0;
-const resolveString = (input) => {
+export const resolveString = (input) => {
     if (typeof input === 'function') {
         input = input();
     }
     return input;
 };
-exports.resolveString = resolveString;
-const resolveRI = (input) => {
+export const resolveRI = (input) => {
     if (typeof input === 'function') {
         input = input();
     }
     return input;
 };
-exports.resolveRI = resolveRI;

package/dist/ws-client.d.ts

@@ -1,6 +1,6 @@
-import { type RpcMessage, type RpcRequest, type ErrorMap } from './rpcmessage';
-import { type RpcValue, type Null, type Int, type IMap, type ShvMap } from './rpcvalue';
-import { type RIGetter } from './utils';
+import { type RpcMessage, type RpcRequest, type ErrorMap } from './rpcmessage.js';
+import { type RpcValue, type Null, type Int, type IMap, type ShvMap } from './rpcvalue.js';
+import { type RIGetter } from './utils.js';
 type SubscriptionCallback = (path: string, signal: string, param?: RpcValue) => void;
 type ResultOrError<T = RpcValue> = T | Error;
 type Login = {
@@ -209,6 +209,7 @@ export type CallRpcMethodOptions = {
     delayCallback?: (progress: number) => void;
     requestUserId?: boolean;
     beforeSendHook?: (rpcMessage: RpcRequest) => RpcRequest;
+    explicitNullParam?: boolean;
 };
 declare enum ShvApiVersion {
     V2 = 0,