libshv-js 3.16.1 → 3.20.0

package/dist/rpcvalue.js

@@ -0,0 +1,100 @@
+"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) {
+        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()}`;
+    }
+}
+exports.UInt = UInt;
+class Double {
+    value;
+    constructor(u) {
+        this.value = u;
+    }
+}
+exports.Double = Double;
+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;
+    }
+}
+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) => {
+    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>';
+    }
+};
+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;
+    constructor(meta, value) {
+        this.meta = meta;
+        this.value = value;
+        /* nothing */
+    }
+}
+exports.RpcValueWithMetaData = RpcValueWithMetaData;

package/dist/vue-shv.d.ts

@@ -0,0 +1,91 @@
+import { ComputedRef, Ref } from 'vue';
+import { WsClient, WsClientOptionsLogin } from './ws-client';
+import PKCE from 'js-pkce';
+import * as z from './zod';
+import { type shvMapType } from './rpcvalue';
+import { RpcValue } from './rpcvalue';
+type GlobalResourceOptions<ResourceType> = {
+    shvPath: string;
+    method: string;
+    validator: z.ZodType<ResourceType>;
+    signalName: string;
+    signalHandler: (param: RpcValue, resource: Ref<ResourceType | undefined>, reinit: () => void) => void;
+};
+type VueShvOptions = {
+    wsUri: string;
+    onRequest: WsClientOptionsLogin['onRequest'];
+    azureCodeRedirect?: string;
+};
+type ShvLocalStorage = {
+    azureAccessToken?: string;
+    azureRedirectTo?: string;
+};
+type ShvSessionStorage = {
+    shvLoginUser?: string;
+    shvLoginPassword?: string;
+    azureWorkflow?: z.infer<typeof OAuth2AzureWorkflowZod>;
+};
+declare const OAuth2AzureWorkflowZod: z.ZodCustom<{
+    type: "oauth2-azure";
+    authorizeUrl: string;
+    tokenUrl: string;
+    clientId: string;
+    scopes: string | string[];
+} & {
+    [shvMapType]: "map";
+}, {
+    type: "oauth2-azure";
+    authorizeUrl: string;
+    tokenUrl: string;
+    clientId: string;
+    scopes: string | string[];
+} & {
+    [shvMapType]: "map";
+}>;
+export declare enum LoginFailureReason {
+    NoCredentials = 0,
+    AzureTimedOut = 1,
+    AzureUnsupported = 2,
+    CouldntLogin = 3,
+    LoggedOut = 4
+}
+type LoginFailure = {
+    reason: LoginFailureReason;
+    message?: string;
+};
+declare const makePkce: (oauthOptions: {
+    azureCodeRedirect: string;
+    clientId: string;
+    authorizeUrl: string;
+    tokenUrl: string;
+    scopes: string | string[];
+}) => PKCE;
+export { makePkce as azure };
+export declare function useShv(options: VueShvOptions): {
+    azureAuth: (redirectTo?: string) => void;
+    azureHandlerError: Ref<string, string>;
+    connected: Ref<"connected" | "connecting" | "disconnected", "connected" | "connecting" | "disconnected">;
+    displayEmail: Ref<string, string>;
+    displayFullName: Ref<string, string>;
+    displayName: Ref<string, string>;
+    displayPhoto: Ref<string | undefined, string | undefined>;
+    displayShortName: Ref<string, string>;
+    getConnection: () => Promise<WsClient>;
+    handleAzureCode: () => Promise<string | void>;
+    logContents: Ref<string, string>;
+    loginFailure: Ref<LoginFailure | undefined, LoginFailure | undefined>;
+    makeGlobalResource: {
+        <ResourceType>(options: GlobalResourceOptions<ResourceType>): () => Ref<ResourceType | undefined>;
+        <ResourceType>(options: GlobalResourceOptions<ResourceType> & {
+            default: ResourceType;
+        }): () => ComputedRef<ResourceType>;
+    };
+    makeRpcCall: <ResultType>(shvPath: string, method: string, validator: z.ZodType<ResultType>) => () => Promise<Error | ResultType>;
+    makeRpcCallParam: <ResultType, ParamType extends RpcValue>(shvPath: string, method: string, _paramType: z.ZodType<ParamType>, validator: z.ZodType<ResultType>) => (param: ParamType) => Promise<Error | ResultType>;
+    rpcCall: (shvPath: string, method: string, params?: RpcValue) => Promise<Error | RpcValue>;
+    setShvCredentials: (userName: string, password: string) => void;
+    shvLocalStorage: import("@vueuse/shared").RemovableRef<ShvLocalStorage>;
+    shvLogout: () => void;
+    shvSessionStorage: import("@vueuse/shared").RemovableRef<ShvSessionStorage>;
+};
+export declare const fullReloadHandler: (_param: RpcValue, _resource: unknown, reinit: () => void) => void;