@peers-app/peers-sdk 0.6.15 → 0.6.16

package/dist/context/user-context.js

@@ -12,7 +12,6 @@ const utils_1 = require("../utils");
 class UserContext {
     userId;
     dataSourceFactory;
-    // public readonly userId: Observable<string> = observable<string>('');
     deviceId = (0, observable_1.observable)('');
     currentlyActiveGroupId = (0, observable_1.observable)();
     packagesRootDir = (0, observable_1.observable)('');
@@ -21,12 +20,13 @@ class UserContext {
     groupIds = (0, observable_1.observable)([]);
     userDataContext;
     groupDataContexts = new Map();
-    defaultDataContext = (0, observable_1.observable)();
+    defaultDataContext;
     loadingPromise;
     constructor(userId, dataSourceFactory) {
         this.userId = userId;
         this.dataSourceFactory = dataSourceFactory;
         this.userDataContext = new data_context_1.DataContext(this);
+        this.defaultDataContext = (0, observable_1.observable)(this.userDataContext);
         this.defaultDataContext(this.userDataContext);
         this.loadingPromise = this.init();
     }
@@ -114,13 +114,11 @@ class UserContext {
             acc[curr.name] = curr.value?.value;
             return acc;
         }, {});
-        // const userIdPVar = deviceVar<string>('myUserId', { dbValue: varDbValues['myUserId'], userContext: this });
-        // this.userId(userIdPVar());
-        // linkObservables(userIdPVar, this.userId);
-        const deviceIdPVar = (0, data_1.deviceVar)('thisDeviceId', { dbValue: varDbValues['thisDeviceId'], userContext: this });
+        const deviceIdDefaultValue = (typeof process !== 'undefined' && process.env?.DEVICE_ID) || '';
+        const deviceIdPVar = (0, data_1.deviceVar)('thisDeviceId', { defaultValue: deviceIdDefaultValue, dbValue: varDbValues['thisDeviceId'], userContext: this });
         this.deviceId(deviceIdPVar());
         (0, observable_1.linkObservables)(deviceIdPVar, this.deviceId);
-        const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)('currentlyActiveGroupId', { dbValue: varDbValues['currentlyActiveGroupId'], userContext: this });
+        const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)('currentlyActiveGroupId', { dbValue: varDbValues['currentlyActiveGroupId'], defaultValue: '', userContext: this });
         this.currentlyActiveGroupId(currentlyActiveGroupIdPVar());
         (0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId);
         const packagesRootDirPVar = (0, data_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages', dbValue: varDbValues['packagesRootDir'], userContext: this });
@@ -132,16 +130,7 @@ class UserContext {
         const packageLocalPathsResolvedPVar = (0, data_1.deviceVar)('packageLocalPathsResolved', { defaultValue: {}, dbValue: varDbValues['packageLocalPathsResolved'], userContext: this });
         this.packageLocalPathsResolved(packageLocalPathsResolvedPVar());
         (0, observable_1.linkObservables)(packageLocalPathsResolvedPVar, this.packageLocalPathsResolved);
-        if (typeof process !== 'undefined' && process.env) {
-            // if (process.env.USER_ID) {
-            //   this.userId(process.env.USER_ID);
-            // }
-            if (process.env.DEVICE_ID) {
-                this.deviceId(process.env.DEVICE_ID);
-            }
-        }
         await Promise.all([
-            // userIdPVar.loadingPromise,
             deviceIdPVar.loadingPromise,
             packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,

package/dist/data/devices.d.ts

@@ -48,4 +48,4 @@ export declare function Devices(dataContext?: DataContext): import("..").Table<{
     serverUrl?: string | undefined;
 }>;
 export declare const trustedServers: import("./persistent-vars").PersistentVar<string[]>;
-export declare const thisDeviceId: import("./persistent-vars").PersistentVar<string>;
+export declare const thisDeviceId: import("./persistent-vars").PersistentVar<string | undefined>;

package/dist/data/persistent-vars.d.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
+import { UserContext } from "../context";
+import type { DataContext } from "../context/data-context";
 import { Observable } from "../observable";
+import { ISaveOptions } from "./orm";
 import { Table } from "./orm/table";
 import { ITableMetaData } from "./orm/types";
-import type { DataContext } from "../context/data-context";
-import { UserContext } from "../context";
-import { ISaveOptions } from "./orm";
 declare const schema: z.ZodObject<{
     persistentVarId: z.ZodString;
     name: z.ZodString;
@@ -53,35 +53,47 @@ export type PersistentVar<T> = Observable<T> & {
     loadingPromise: Promise<PersistentVar<T>>;
 };
 export declare function getPersistentVar(name: string, dataContext?: DataContext): Promise<IPersistentVar | undefined>;
-interface IPersistentVarOptions<T> {
+interface IPersistentVarOptionsBase {
     scope?: 'device' | 'user' | 'group' | 'groupDevice' | 'groupUser';
-    defaultValue?: T;
     userContext?: UserContext;
     dataContext?: DataContext;
-    dbValue?: T;
     isSecret?: boolean;
 }
+interface IPersistentVarOptionsWithDefault<T> extends IPersistentVarOptionsBase {
+    defaultValue: T;
+    dbValue?: T;
+}
+interface IPersistentVarOptionsWithoutDefault<T> extends IPersistentVarOptionsBase {
+    defaultValue?: undefined;
+    dbValue?: T;
+}
 /**
  * A persistent variable that is stored only on this device, in the user's personal db
  */
-export declare function deviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+export declare function deviceVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+export declare function deviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, 'scope' | 'dataContext'>): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is stored in the user's personal db and synced across all their devices
  */
-export declare function userVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+export declare function userVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+export declare function userVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, 'scope' | 'dataContext'>): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is shared by all users in a group. It is stored in the group's db and synced across all users and devices in the group.
  * It can have a different value for each group on the device.
+ * If secret=true, it is encrypted with the group's secret key
  */
-export declare function groupVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+export declare function groupVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, 'scope'>): PersistentVar<T>;
+export declare function groupVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, 'scope'>): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is stored only on this device, in the user's personal db.
  * It can have a different value for each group on the device but is not synced to other devices.
  */
-export declare function groupDeviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+export declare function groupDeviceVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, 'scope'>): PersistentVar<T>;
+export declare function groupDeviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, 'scope'>): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is stored in the user's personal db and synced across all their devices in the group.
  * It can have a different value for each user in the group and a different value for each group the user is in.
  */
-export declare function groupUserVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+export declare function groupUserVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, 'scope'>): PersistentVar<T>;
+export declare function groupUserVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, 'scope'>): PersistentVar<T | undefined>;
 export {};

package/dist/data/persistent-vars.js

@@ -10,13 +10,13 @@ exports.groupDeviceVar = groupDeviceVar;
 exports.groupUserVar = groupUserVar;
 const lodash_1 = require("lodash");
 const zod_1 = require("zod");
+const user_context_singleton_1 = require("../context/user-context-singleton");
 const observable_1 = require("../observable");
+const rpc_types_1 = require("../rpc-types");
 const utils_1 = require("../utils");
 const table_1 = require("./orm/table");
-const user_context_singleton_1 = require("../context/user-context-singleton");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
-const rpc_types_1 = require("../rpc-types");
 const schema = zod_1.z.object({
     persistentVarId: zod_1.z.string(),
     name: zod_1.z.string(),
@@ -82,45 +82,60 @@ async function getPersistentVar(name, dataContext) {
     }
     return pVars[0];
 }
-/**
- * A persistent variable that is stored only on this device, in the user's personal db
- */
 function deviceVar(name, opts) {
-    return pvar(name, { ...opts, scope: 'device' });
+    const fullOpts = { ...opts, scope: 'device' };
+    if (opts?.defaultValue !== undefined) {
+        return persistentVarFactory(name, fullOpts);
+    }
+    else {
+        return persistentVarFactory(name, fullOpts);
+    }
 }
-/**
- * A persistent variable that is stored in the user's personal db and synced across all their devices
- */
 function userVar(name, opts) {
-    return pvar(name, { ...opts, scope: 'user' });
+    const fullOpts = { ...opts, scope: 'user' };
+    if (opts?.defaultValue !== undefined) {
+        return persistentVarFactory(name, fullOpts);
+    }
+    else {
+        return persistentVarFactory(name, fullOpts);
+    }
 }
-/**
- * A persistent variable that is shared by all users in a group. It is stored in the group's db and synced across all users and devices in the group.
- * It can have a different value for each group on the device.
- */
 function groupVar(name, opts) {
-    return pvar(name, { ...opts, scope: 'group' });
+    const fullOpts = { ...opts, scope: 'group' };
+    if (opts?.defaultValue !== undefined) {
+        return persistentVarFactory(name, fullOpts);
+    }
+    else {
+        return persistentVarFactory(name, fullOpts);
+    }
 }
-/**
- * A persistent variable that is stored only on this device, in the user's personal db.
- * It can have a different value for each group on the device but is not synced to other devices.
- */
 function groupDeviceVar(name, opts) {
-    return pvar(name, { ...opts, scope: 'groupDevice' });
+    const fullOpts = { ...opts, scope: 'groupDevice' };
+    if (opts?.defaultValue !== undefined) {
+        return persistentVarFactory(name, fullOpts);
+    }
+    else {
+        return persistentVarFactory(name, fullOpts);
+    }
 }
-/**
- * A persistent variable that is stored in the user's personal db and synced across all their devices in the group.
- * It can have a different value for each user in the group and a different value for each group the user is in.
- */
 function groupUserVar(name, opts) {
-    return pvar(name, { ...opts, scope: 'groupUser' });
+    const fullOpts = { ...opts, scope: 'groupUser' };
+    if (opts?.defaultValue !== undefined) {
+        return persistentVarFactory(name, fullOpts);
+    }
+    else {
+        return persistentVarFactory(name, fullOpts);
+    }
 }
-function pvar(name, opts) {
-    const currentValue = (0, observable_1.observable)(opts?.dbValue || opts?.defaultValue);
+function persistentVarFactory(name, opts) {
+    const setWithDbValue = Object.keys(opts ?? {}).includes('dbValue');
+    const defaultValue = opts?.defaultValue;
+    const initialValue = setWithDbValue ? opts?.dbValue : defaultValue;
+    const persistentVar = (initialValue !== undefined ? (0, observable_1.observable)(initialValue) : (0, observable_1.observable)());
     const scope = opts.scope || 'device';
     let isSecret = opts.isSecret;
     let rec = undefined;
-    currentValue.loadingPromise = new Promise(async (resolve) => {
+    persistentVar.loadingPromise = new Promise(async (resolve) => {
         const userContext = opts?.userContext || await (0, user_context_singleton_1.getUserContext)();
         function getDataContext() {
             if (opts?.dataContext) {
@@ -155,11 +170,11 @@ function pvar(name, opts) {
             }
             if (!dbRec) {
                 dbRec = {
-                    persistentVarId: (0, utils_1.newid)(),
+                    persistentVarId: '',
                     name,
                     scope,
                     isSecret,
-                    value: { value: opts?.defaultValue },
+                    value: { value: defaultValue },
                 };
             }
             // if the db says it's secret but the caller didn't specify, assume it's secret
@@ -168,8 +183,13 @@ function pvar(name, opts) {
             }
             return dbRec;
         }
-        async function saveVarToDb(value) {
-            if (!rec) {
+        async function reactToValueChanged(value) {
+            if (name === 'colorModePreference')
+                console.log(`colorModePreferences pvar value set: ${value}`);
+            if (!rec?.persistentVarId && value === defaultValue) {
+                return;
+            }
+            if (!rec?.persistentVarId) {
                 rec = await loadRecFromDb();
             }
             const oldValue = rec.value.value;
@@ -180,51 +200,82 @@ function pvar(name, opts) {
             const dc = getDataContext();
             const table = PersistentVars(dc);
             // delete if value equals default value
-            if (rec.value.value === opts?.defaultValue) {
-                await table.delete(rec);
-                rec.persistentVarId = (0, utils_1.newid)();
+            if ((0, lodash_1.isEqual)(rec.value.value, defaultValue)) {
+                if (rec.persistentVarId) {
+                    if (name === 'colorModePreference') {
+                        console.log(`deleted persistent var ${name} from db:`, rec.value.value);
+                    }
+                    await table.delete(rec);
+                }
+                rec = undefined;
             }
             else {
-                await table.save(rec);
+                try {
+                    await table.save(rec);
+                    if (name === 'colorModePreference') {
+                        console.log(`Saved var ${name} to db:`, rec.value.value);
+                    }
+                }
+                catch (err) {
+                    const errMsg = err?.message || String(err) || '';
+                    if (errMsg.includes('UNIQUE constraint failed')) {
+                        console.warn(`Detected UNIQUE constraint failed error when saving persistent var, reloading and retrying: ${name}`);
+                        rec = await loadRecFromDb();
+                        persistentVar(rec.value.value);
+                    }
+                    else {
+                        console.error('Error saving persistent var', { name, value, rec, err });
+                        throw err;
+                    }
+                }
             }
         }
         // subscribe to db changes
         userContext.subscribeToDataChangedAcrossAllGroups(PersistentVars(), async (evt) => {
             const dbRec = evt.data.dataObject;
             const dbName = getVarNameInDb();
-            if (dbRec.name === dbName && !rec) {
-                rec = await loadRecFromDb();
+            if (!rec?.persistentVarId && dbRec.name === dbName) {
+                rec = dbRec;
             }
             if (dbRec.persistentVarId === rec?.persistentVarId) {
-                rec = dbRec;
                 if (evt.data.op === 'delete') {
-                    rec.persistentVarId = (0, utils_1.newid)(); // change id so next save creates new pVar
-                    rec.value.value = opts?.defaultValue;
+                    rec = undefined;
+                    if (defaultValue !== undefined) {
+                        persistentVar(defaultValue);
+                    }
                 }
-                if (!(0, lodash_1.isEqual)(currentValue(), rec.value.value)) {
-                    currentValue(rec.value.value);
+                else {
+                    rec = dbRec;
+                    if (!(0, lodash_1.isEqual)(persistentVar(), rec.value.value)) {
+                        persistentVar(rec.value.value);
+                    }
                 }
-                return;
             }
         });
         // update group-dependent variables if group context changes and it hasn't been pinned to a specific data context
         const groupDependentScopes = ['group', 'groupDevice', 'groupUser'];
         if (!opts?.dataContext && groupDependentScopes.includes(scope)) {
-            userContext.defaultDataContext.subscribe(async (newDataContext) => {
+            userContext.defaultDataContext.subscribe(async () => {
                 rec = await loadRecFromDb();
-                currentValue(rec.value.value);
+                persistentVar(rec.value.value);
             });
         }
-        if (!Object.keys(opts ?? {}).includes('dbValue')) {
+        if (!setWithDbValue) {
             rec = await loadRecFromDb();
-            if (!(0, lodash_1.isEqual)(rec.value.value, currentValue())) {
-                currentValue(rec.value.value);
+            if (!(0, lodash_1.isEqual)(rec.value.value, persistentVar())) {
+                if (name === 'colorModePreference') {
+                    console.log(`Loaded persistent var ${name} from db:`, rec.value.value);
+                }
+                persistentVar(rec.value.value);
             }
         }
-        currentValue.subscribe(newValue => {
-            saveVarToDb(newValue);
+        persistentVar.subscribe(newValue => {
+            persistentVar.loadingPromise = persistentVar.loadingPromise.then(async () => {
+                await reactToValueChanged(newValue);
+                return persistentVar;
+            });
         });
-        resolve(currentValue);
+        resolve(persistentVar);
     });
-    return currentValue;
+    return persistentVar;
 }

package/dist/observable.d.ts

@@ -1,14 +1,18 @@
-type ObservableFn<T> = ((newValue?: T) => T);
+type ObservableFn<T> = {
+    (): T;
+    (newValue: T): T;
+};
 export type Subscription = {
     dispose: () => void;
 };
 type ObservableProps<T> = {
     subscribe: (subscriber: (newValue: T) => void) => Subscription;
-    notifySubscribers: (newValue?: T) => void;
+    notifySubscribers: () => void;
     subscriberCount: () => number;
 };
 export type Observable<T> = ObservableFn<T> & ObservableProps<T>;
-export declare function observable<T>(initialValue?: T): Observable<T>;
+export declare function observable<T>(initialValue: T): Observable<T>;
+export declare function observable<T = undefined>(): Observable<T | undefined>;
 export declare function computed<T>(fn: ({
     read: () => T;
     write?: (val: T) => void;

package/dist/observable.js

@@ -12,20 +12,18 @@ const runningComputes = {};
 function observable(initialValue) {
     let value = initialValue;
     const subscribers = [];
-    const obs = ((newValue) => {
+    const obs = ((...args) => {
         Object.values(runningComputes).forEach(c => c.push(obs));
-        if (newValue !== undefined && newValue !== value) {
+        const isSetting = args.length > 0;
+        const newValue = args[0];
+        if (isSetting && newValue !== value) {
             value = newValue;
             obs.notifySubscribers();
         }
-        // TODO - get typings to say if a value is passed in it's type T otherwise it's T | undefined
         return value;
     });
-    obs.notifySubscribers = (newValue) => {
-        if (newValue !== undefined) {
-            value = newValue;
-        }
-        subscribers.forEach(subscriber => subscriber(value)); // TODO fix typing here too
+    obs.notifySubscribers = () => {
+        subscribers.forEach(subscriber => subscriber(value));
     };
     obs.subscribe = (subscriber) => {
         subscribers.push(subscriber);

package/dist/observable.test.js

@@ -29,6 +29,132 @@ describe('observable.ts', () => {
             const obs = (0, observable_1.observable)(3);
             expect(obs(4)).toBe(4);
         });
+        it('should be able to set an observable to undefined', () => {
+            const obs = (0, observable_1.observable)(3);
+            obs(undefined);
+            expect(obs()).toBe(undefined);
+        });
+        it('should notify subscribers when value is set to undefined', () => {
+            const obs = (0, observable_1.observable)(3);
+            let value = 99;
+            const sub = obs.subscribe(newValue => {
+                value = newValue;
+            });
+            obs(undefined);
+            expect(value).toBe(undefined);
+            sub.dispose();
+        });
+        it('should be able to initialize an observable with undefined', () => {
+            const obs = (0, observable_1.observable)(undefined);
+            expect(obs()).toBe(undefined);
+        });
+        it('should distinguish between getting (no args) and setting to undefined (with arg)', () => {
+            const obs = (0, observable_1.observable)(5);
+            // Getting with no args
+            expect(obs()).toBe(5);
+            // Setting to undefined with explicit arg
+            obs(undefined);
+            expect(obs()).toBe(undefined);
+        });
+        it('should not notify subscribers when value does not change', () => {
+            const obs = (0, observable_1.observable)(3);
+            let notifyCount = 0;
+            obs.subscribe(() => {
+                notifyCount++;
+            });
+            obs(3);
+            expect(notifyCount).toBe(0);
+            obs(4);
+            expect(notifyCount).toBe(1);
+        });
+        it('should handle setting undefined multiple times', () => {
+            const obs = (0, observable_1.observable)('test');
+            let notifyCount = 0;
+            obs.subscribe(() => {
+                notifyCount++;
+            });
+            obs(undefined);
+            expect(notifyCount).toBe(1);
+            obs(undefined);
+            // Should not notify since value hasn't changed
+            expect(notifyCount).toBe(1);
+            obs('new');
+            expect(notifyCount).toBe(2);
+            obs(undefined);
+            expect(notifyCount).toBe(3);
+        });
+        it('should correctly detect args.length for get vs set', () => {
+            const obs = (0, observable_1.observable)(10);
+            const calls = [];
+            // Wrap the observable to track calls
+            const originalObs = obs;
+            const wrappedObs = ((...args) => {
+                calls.push({ argsLength: args.length, value: args[0] });
+                return originalObs(...args);
+            });
+            Object.assign(wrappedObs, obs);
+            // Get (no args)
+            wrappedObs();
+            expect(calls[0]).toEqual({ argsLength: 0, value: undefined });
+            // Set to undefined (1 arg)
+            wrappedObs(undefined);
+            expect(calls[1]).toEqual({ argsLength: 1, value: undefined });
+            // Get again (no args)
+            wrappedObs();
+            expect(calls[2]).toEqual({ argsLength: 0, value: undefined });
+        });
+        it('should allow creating observable without initial value for types that include undefined', () => {
+            const obs = (0, observable_1.observable)();
+            expect(obs()).toBe(undefined);
+            obs('test');
+            expect(obs()).toBe('test');
+            obs(undefined);
+            expect(obs()).toBe(undefined);
+        });
+        it('should work with explicit type and initial value', () => {
+            const obs = (0, observable_1.observable)(42);
+            expect(obs()).toBe(42);
+            obs(100);
+            expect(obs()).toBe(100);
+        });
+        it('should not allow creating observable without initial value for types that cannot be undefined', () => {
+            const obs = (0, observable_1.observable)();
+            // @ts-expect-error
+            const s = obs();
+            expect(s).toBeUndefined();
+            obs('s');
+            expect(obs()).toEqual('s');
+            obs(undefined);
+            expect(obs()).toEqual(undefined);
+            const obs2 = (0, observable_1.observable)('');
+            const s2 = obs2();
+            expect(s2).toEqual('');
+            // @ts-expect-error
+            obs2(undefined);
+            expect(obs2()).toBeUndefined();
+        });
+        it('should infer type from initial value', () => {
+            // Infer number from numeric literal
+            const numObs = (0, observable_1.observable)(42);
+            const num = numObs();
+            expect(num).toBe(42);
+            // Infer string from string literal
+            const strObs = (0, observable_1.observable)('hello');
+            const str = strObs();
+            expect(str).toBe('hello');
+            // Infer boolean from boolean literal
+            const boolObs = (0, observable_1.observable)(true);
+            const bool = boolObs();
+            expect(bool).toBe(true);
+            // Infer object type
+            const objObs = (0, observable_1.observable)({ name: 'test', count: 5 });
+            const obj = objObs();
+            expect(obj).toEqual({ name: 'test', count: 5 });
+            // Infer array type
+            const arrObs = (0, observable_1.observable)([1, 2, 3]);
+            const arr = arrObs();
+            expect(arr).toEqual([1, 2, 3]);
+        });
     });
     describe('computed', () => {
         it('should be able to create a computed observable', () => {
@@ -160,10 +286,10 @@ describe('observable.ts', () => {
             expect(recomputeCount).toBe(2);
             expect(com1()).toBe(4);
             expect(com1()).toBe(4);
-            com1.notifySubscribers(5);
-            expect(newValue).toBe(5);
-            expect(com1()).toBe(5);
-            expect(recomputeCount).toBe(2);
+            // com1.notifySubscribers(5);
+            // expect(newValue).toBe(5);
+            // expect(com1()).toBe(5);
+            // expect(recomputeCount).toBe(2);
         });
         it('should allow configuring a write function', () => {
             const obs1 = (0, observable_1.observable)(1);

package/dist/rpc-types.d.ts

@@ -34,7 +34,6 @@ export declare const rpcServerCalls: {
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
     resetAllDeviceSyncInfo: (() => Promise<void>);
     importGroupShare: ((groupShareJson: string) => Promise<string>);
-    setAppTheme: ((theme: "light" | "dark") => Promise<void>);
 };
 export declare const rpcClientCalls: {
     ping: (msg: string) => Promise<string>;

package/dist/rpc-types.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isClient = exports.rpcClientCalls = exports.rpcServerCalls = void 0;
 function rpcStub(rpcName) {
-    return async () => {
-        console.warn(rpcName + ': rpc fn not set. This means that an RPC call is happening before the RPC function has been set. This is either a race condition or the RPC handler was never set.');
+    return async (...args) => {
+        console.warn(rpcName + ': rpc fn not set. This means that an RPC call is happening before the RPC function has been set. This is either a race condition or the RPC handler was never set.' + JSON.stringify({ rpcName, args }, null, 2));
     };
 }
 exports.rpcServerCalls = {
@@ -31,7 +31,6 @@ exports.rpcServerCalls = {
     getFileContents: rpcStub('getFileContents'),
     resetAllDeviceSyncInfo: rpcStub('resetAllDeviceSyncInfo'),
     importGroupShare: rpcStub('importGroupShare'),
-    setAppTheme: rpcStub('setAppTheme'),
     // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
     // emitEvent: _na as ((event: IEventData) => Promise<boolean>),
 };

package/dist/utils.d.ts

@@ -15,8 +15,8 @@ export declare function simpleHash(str: string): number;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export declare function simpleObjectHash(obj: any): number;
 export declare function sleep(ms?: number): Promise<void>;
-export declare function camelCaseToSpaces(s: string): string;
-export declare function camelCaseToHyphens(s: string): string;
+export declare function camelCaseToSpaces(s?: string): string;
+export declare function camelCaseToHyphens(s?: string): string;
 export declare const moneyFormatter: Intl.NumberFormat;
 export declare function formatMoney(value: number, precision?: number): string;
 export declare function memoizePromise<F extends (...args: any[]) => Promise<any>>(fn: F, opts?: {

package/dist/utils.js

@@ -109,14 +109,14 @@ function simpleObjectHash(obj) {
 function sleep(ms = 0) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-function camelCaseToSpaces(s) {
+function camelCaseToSpaces(s = '') {
     s = s.replace(/([a-z])([A-Z])/g, '$1 $2');
     // s = s.replace(/(GL)([A-Z])/g, '$1 $2');  // anything like GLAccounts, GLBatches, etc. 
     s = s.replace("_", " ");
     s = s[0]?.toUpperCase() + s.substr(1);
     return s;
 }
-function camelCaseToHyphens(s) {
+function camelCaseToHyphens(s = '') {
     s = camelCaseToSpaces(s);
     return s.split(' ').join('-').toLowerCase();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"