socket-function 0.9.0 → 0.9.1

package/SocketFunctionTypes.ts

@@ -1,91 +1,91 @@
-/// <reference path="./require/RequireController.ts" />
-
-module.allowclient = true;
-
-import { SocketFunction } from "./SocketFunction";
-import { getCallObj } from "./src/nodeProxy";
-import { Args, MaybePromise } from "./src/types";
-
-export const socket = Symbol("socket");
-
-export type SocketExposedInterface = {
-    [functionName: string]: (...args: any[]) => Promise<unknown>;
-};
-export type SocketInternalInterface = {
-    [functionName: string]: {
-        [getCallObj]: (...args: any[]) => FullCallType;
-        (...args: any[]): Promise<unknown>;
-    }
-}
-export type SocketExposedInterfaceClass = {
-    //new(): SocketExposedInterface;
-    new(): unknown;
-    prototype: unknown;
-};
-export interface SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
-    [functionName: string]: {
-        /** Indicates with the same input, we give the same output, forever,
-         *      independent of code changes. This only works for data storage.
-         */
-        dataImmutable?: boolean;
-        hooks?: SocketFunctionHook<ExposedType>[];
-        clientHooks?: SocketFunctionClientHook<ExposedType>[];
-    };
-}
-
-export interface CallType {
-    classGuid: string;
-    functionName: string;
-    args: unknown[];
-}
-export interface FullCallType extends CallType {
-    nodeId: string;
-}
-
-export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
-    (config: HookContext<ExposedType>): MaybePromise<void>;
-    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
-    clientHook?: SocketFunctionClientHook<ExposedType>;
-}
-export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
-    call: FullCallType;
-    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
-    overrideResult?: unknown;
-};
-
-export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
-    call: FullCallType;
-    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
-    overrideResult?: unknown;
-    connectionId: { nodeId: string };
-};
-export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
-    (config: ClientHookContext<ExposedType>): MaybePromise<void>;
-}
-
-export interface SocketRegistered<ExposedType = any> {
-    nodes: {
-        // NOTE: Don't pass around nodeId to other nodes, instead pass around NetworkLocation (which they
-        //  then turn into a nodeId, which they can then check permissions on themself).
-        [nodeId: string]: {
-            [functionName in keyof ExposedType]: ExposedType[functionName] & {
-                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
-            }
-        };
-    };
-    _classGuid: string;
-}
-export type CallerContext = Readonly<CallerContextBase>;
-export type CallerContextBase = {
-    // IMPORTANT! Do not pass nodeId to other nodes with the intention of having
-    //  them call functions directly using nodeId. Instead pass location, and have them use connect.
-    //  - nodeId will be unique per thread, so is only useful for temporary communcation. If you want
-    //      a more permanent identity, you must derive it from certInfo yourself.
-    nodeId: string;
-
-    // The nodeId they contacted. This is useful to determine their intention (otherwise
-    //  requests can be redirected to us and would accept them, even though they are being
-    //  blatantly MITMed).
-    //  IF they are the server, calling us back, then this will just be ""
-    localNodeId: string;
+/// <reference path="./require/RequireController.ts" />
+
+module.allowclient = true;
+
+import { SocketFunction } from "./SocketFunction";
+import { getCallObj } from "./src/nodeProxy";
+import { Args, MaybePromise } from "./src/types";
+
+export const socket = Symbol("socket");
+
+export type SocketExposedInterface = {
+    [functionName: string]: (...args: any[]) => Promise<unknown>;
+};
+export type SocketInternalInterface = {
+    [functionName: string]: {
+        [getCallObj]: (...args: any[]) => FullCallType;
+        (...args: any[]): Promise<unknown>;
+    }
+}
+export type SocketExposedInterfaceClass = {
+    //new(): SocketExposedInterface;
+    new(): unknown;
+    prototype: unknown;
+};
+export interface SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
+    [functionName: string]: {
+        /** Indicates with the same input, we give the same output, forever,
+         *      independent of code changes. This only works for data storage.
+         */
+        dataImmutable?: boolean;
+        hooks?: SocketFunctionHook<ExposedType>[];
+        clientHooks?: SocketFunctionClientHook<ExposedType>[];
+    };
+}
+
+export interface CallType {
+    classGuid: string;
+    functionName: string;
+    args: unknown[];
+}
+export interface FullCallType extends CallType {
+    nodeId: string;
+}
+
+export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
+    (config: HookContext<ExposedType>): MaybePromise<void>;
+    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+    clientHook?: SocketFunctionClientHook<ExposedType>;
+}
+export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+    call: FullCallType;
+    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
+    overrideResult?: unknown;
+};
+
+export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+    call: FullCallType;
+    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
+    overrideResult?: unknown;
+    connectionId: { nodeId: string };
+};
+export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
+    (config: ClientHookContext<ExposedType>): MaybePromise<void>;
+}
+
+export interface SocketRegistered<ExposedType = any> {
+    nodes: {
+        // NOTE: Don't pass around nodeId to other nodes, instead pass around NetworkLocation (which they
+        //  then turn into a nodeId, which they can then check permissions on themself).
+        [nodeId: string]: {
+            [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+            }
+        };
+    };
+    _classGuid: string;
+}
+export type CallerContext = Readonly<CallerContextBase>;
+export type CallerContextBase = {
+    // IMPORTANT! Do not pass nodeId to other nodes with the intention of having
+    //  them call functions directly using nodeId. Instead pass location, and have them use connect.
+    //  - nodeId will be unique per thread, so is only useful for temporary communcation. If you want
+    //      a more permanent identity, you must derive it from certInfo yourself.
+    nodeId: string;
+
+    // The nodeId they contacted. This is useful to determine their intention (otherwise
+    //  requests can be redirected to us and would accept them, even though they are being
+    //  blatantly MITMed).
+    //  IF they are the server, calling us back, then this will just be ""
+    localNodeId: string;
 };

package/hot/HotReloadController.ts

@@ -1,106 +1,106 @@
-/// <reference path="../../typenode/index.d.ts" />
-/// <reference path="../require/RequireController.ts" />
-module.allowclient = true;
-
-import { SocketFunction } from "../SocketFunction";
-import { cache, lazy } from "../src/caching";
-import * as fs from "fs";
-import debugbreak from "debugbreak";
-import { isNode } from "../src/misc";
-import { red } from "../src/formatting/logColors";
-
-/** Enables some hot reload functionality.
- *      - Triggers a refresh clientside
- *      - Triggers a reload server, for modules marked with `module.hotreload`
- */
-export function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false) {
-
-    SocketFunction.expose(HotReloadController);
-    if (!isNode()) {
-        if (!noAutomaticBrowserWatch) {
-            HotReloadController.nodes[SocketFunction.locationNode()]
-                .watchFiles()
-                .catch(e => console.error("watchFiles error", e))
-                ;
-        }
-    }
-    setInterval(() => {
-        for (let module of Object.values(require.cache)) {
-            if (!module) continue;
-            hotReloadModule(module);
-        }
-    }, 5000);
-}
-
-declare global {
-    namespace NodeJS {
-        interface Module {
-            hotreload?: boolean;
-            noserverhotreload?: boolean;
-        }
-    }
-}
-
-const hotReloadModule = cache((module: NodeJS.Module) => {
-    if (!module.updateContents) return;
-    fs.watchFile(module.filename, { persistent: false, interval: 1000 }, (curr, prev) => {
-        if (curr.mtime.getTime() === prev.mtime.getTime()) return;
-        console.log(`Hot reloading due to change: ${module.filename}`);
-        module.updateContents?.();
-        if (isNode()) {
-            if (
-                module.hotreload
-                // A fairly big hack (as this could just be in a string, or something similar), but... it also VERY useful
-                || module.moduleContents?.includes("\nmodule.hotreload = true;" + "\n")
-                || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
-            ) {
-                console.log(`Reloading ${module.id}`);
-                try {
-                    module.loaded = false;
-                    module.load(module.id);
-                } catch (e) {
-                    console.error(red(`Error hot reloading ${module.id}`));
-                    console.error(e);
-                }
-            }
-        }
-        triggerClientSideReload();
-    });
-});
-let reloadTriggering = false;
-let clientWatcherNodes = new Set<string>();
-function triggerClientSideReload() {
-    if (reloadTriggering) return;
-    reloadTriggering = true;
-    setTimeout(async () => {
-        reloadTriggering = false;
-        for (let clientNodeId of clientWatcherNodes) {
-            console.log(`Notifying client of hot reload: ${clientNodeId}`);
-            HotReloadController.nodes[clientNodeId].fileUpdated().catch(() => {
-                console.log(`Removing erroring client: ${clientNodeId}`);
-                clientWatcherNodes.delete(clientNodeId);
-            });
-        }
-    }, 300);
-}
-
-class HotReloadControllerBase {
-    // TODO: Also hot reload when we reconnect to the server, as it is likely setup will need to
-    //  be rerun in that case as well (for example, we need to call watchFiles again!)
-    async watchFiles() {
-        let callerId = SocketFunction.getCaller().nodeId;
-        clientWatcherNodes.add(callerId);
-    }
-    async fileUpdated() {
-        document.location.reload();
-    }
-}
-
-export const HotReloadController = SocketFunction.register(
-    "HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5",
-    new HotReloadControllerBase(),
-    () => ({
-        watchFiles: {},
-        fileUpdated: {}
-    })
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference path="../require/RequireController.ts" />
+module.allowclient = true;
+
+import { SocketFunction } from "../SocketFunction";
+import { cache, lazy } from "../src/caching";
+import * as fs from "fs";
+import debugbreak from "debugbreak";
+import { isNode } from "../src/misc";
+import { red } from "../src/formatting/logColors";
+
+/** Enables some hot reload functionality.
+ *      - Triggers a refresh clientside
+ *      - Triggers a reload server, for modules marked with `module.hotreload`
+ */
+export function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false) {
+
+    SocketFunction.expose(HotReloadController);
+    if (!isNode()) {
+        if (!noAutomaticBrowserWatch) {
+            HotReloadController.nodes[SocketFunction.locationNode()]
+                .watchFiles()
+                .catch(e => console.error("watchFiles error", e))
+                ;
+        }
+    }
+    setInterval(() => {
+        for (let module of Object.values(require.cache)) {
+            if (!module) continue;
+            hotReloadModule(module);
+        }
+    }, 5000);
+}
+
+declare global {
+    namespace NodeJS {
+        interface Module {
+            hotreload?: boolean;
+            noserverhotreload?: boolean;
+        }
+    }
+}
+
+const hotReloadModule = cache((module: NodeJS.Module) => {
+    if (!module.updateContents) return;
+    fs.watchFile(module.filename, { persistent: false, interval: 1000 }, (curr, prev) => {
+        if (curr.mtime.getTime() === prev.mtime.getTime()) return;
+        console.log(`Hot reloading due to change: ${module.filename}`);
+        module.updateContents?.();
+        if (isNode()) {
+            if (
+                module.hotreload
+                // A fairly big hack (as this could just be in a string, or something similar), but... it also VERY useful
+                || module.moduleContents?.includes("\nmodule.hotreload = true;" + "\n")
+                || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
+            ) {
+                console.log(`Reloading ${module.id}`);
+                try {
+                    module.loaded = false;
+                    module.load(module.id);
+                } catch (e) {
+                    console.error(red(`Error hot reloading ${module.id}`));
+                    console.error(e);
+                }
+            }
+        }
+        triggerClientSideReload();
+    });
+});
+let reloadTriggering = false;
+let clientWatcherNodes = new Set<string>();
+function triggerClientSideReload() {
+    if (reloadTriggering) return;
+    reloadTriggering = true;
+    setTimeout(async () => {
+        reloadTriggering = false;
+        for (let clientNodeId of clientWatcherNodes) {
+            console.log(`Notifying client of hot reload: ${clientNodeId}`);
+            HotReloadController.nodes[clientNodeId].fileUpdated().catch(() => {
+                console.log(`Removing erroring client: ${clientNodeId}`);
+                clientWatcherNodes.delete(clientNodeId);
+            });
+        }
+    }, 300);
+}
+
+class HotReloadControllerBase {
+    // TODO: Also hot reload when we reconnect to the server, as it is likely setup will need to
+    //  be rerun in that case as well (for example, we need to call watchFiles again!)
+    async watchFiles() {
+        let callerId = SocketFunction.getCaller().nodeId;
+        clientWatcherNodes.add(callerId);
+    }
+    async fileUpdated() {
+        document.location.reload();
+    }
+}
+
+export const HotReloadController = SocketFunction.register(
+    "HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5",
+    new HotReloadControllerBase(),
+    () => ({
+        watchFiles: {},
+        fileUpdated: {}
+    })
 );

package/mobx/UrlParam.ts

@@ -1,40 +1,40 @@
-import { observable } from "mobx";
-import { isNode } from "../src/misc";
-
-// TODO: Batch url state changes
-// TODO: Create actual links, that a tag can use
-//  - Then after that, support not reloading the page, instead just setting the observables,
-//      for faster navigation.
-
-export class UrlParam<T> {
-    constructor(private key: string, private defaultValue: T) { }
-    valueSeqNum = observable({ value: 1 });
-    public get(): T {
-        urlBackSeqNum.value;
-        this.valueSeqNum.value;
-        let value = new URL(location.href).searchParams.get(this.key);
-        if (value === null) {
-            return this.defaultValue;
-        }
-        return JSON.parse(value) as T;
-    }
-    public set(value: T) {
-        let url = new URL(location.href);
-        url.searchParams.set(this.key, JSON.stringify(value));
-        history.pushState({}, "", url.toString());
-        this.valueSeqNum.value++;
-    }
-    public reset() {
-        let url = new URL(location.href);
-        url.searchParams.delete(this.key);
-        history.pushState({}, "", url.toString());
-        this.valueSeqNum.value++;
-    }
-}
-
-let urlBackSeqNum = observable({ value: 1 });
-if (!isNode()) {
-    window.addEventListener("popstate", () => {
-        urlBackSeqNum.value++;
-    });
+import { observable } from "mobx";
+import { isNode } from "../src/misc";
+
+// TODO: Batch url state changes
+// TODO: Create actual links, that a tag can use
+//  - Then after that, support not reloading the page, instead just setting the observables,
+//      for faster navigation.
+
+export class UrlParam<T> {
+    constructor(private key: string, private defaultValue: T) { }
+    valueSeqNum = observable({ value: 1 });
+    public get(): T {
+        urlBackSeqNum.value;
+        this.valueSeqNum.value;
+        let value = new URL(location.href).searchParams.get(this.key);
+        if (value === null) {
+            return this.defaultValue;
+        }
+        return JSON.parse(value) as T;
+    }
+    public set(value: T) {
+        let url = new URL(location.href);
+        url.searchParams.set(this.key, JSON.stringify(value));
+        history.pushState({}, "", url.toString());
+        this.valueSeqNum.value++;
+    }
+    public reset() {
+        let url = new URL(location.href);
+        url.searchParams.delete(this.key);
+        history.pushState({}, "", url.toString());
+        this.valueSeqNum.value++;
+    }
+}
+
+let urlBackSeqNum = observable({ value: 1 });
+if (!isNode()) {
+    window.addEventListener("popstate", () => {
+        urlBackSeqNum.value++;
+    });
 }

package/mobx/observer.tsx

@@ -1,50 +1,50 @@
-import type preact from "preact";
-import { setFlag } from "../require/compileFlags";
-
-import { observable, Reaction } from "mobx";
-
-setFlag(require, "mobx", "allowclient", true);
-setFlag(require, "preact", "allowclient", true);
-
-let globalConstructOrder = 0;
-
-export function observer<
-    T extends {
-        new(...args: any[]): {
-            render(): preact.ComponentChild;
-            forceUpdate(callback?: () => void): void;
-            componentWillUnmount?(): void;
-        }
-    }
->(
-    Constructor: T
-) {
-    let name = Constructor.name;
-    return class extends Constructor {
-        // NOTE: This is completely valid javascript. For some reason (https://github.com/microsoft/TypeScript/pull/12065#issuecomment-270205513)
-        //  the typescript team decided, whatever, just make it an error, even though it isn't in es6 ("we should simplify ES6' semantics").
-        //  So, instead of simplifying ES6 semantics, lets give ourself better info for debugging...
-        // @ts-ignore
-        static get name() { return Constructor.name; }
-
-        // It is always true, that a parent has a constructOrder < a child's constructOrder
-        constructOrder = globalConstructOrder++;
-
-        reaction = new Reaction(`render.${name}.${this.constructOrder}`, () => {
-            super.forceUpdate();
-        });
-
-        componentWillUnmount() {
-            this.reaction.dispose();
-            super.componentWillUnmount?.();
-        }
-
-        render() {
-            let output: preact.ComponentChild;
-            this.reaction.track(() => {
-                output = super.render();
-            });
-            return output;
-        }
-    };
+import type preact from "preact";
+import { setFlag } from "../require/compileFlags";
+
+import { observable, Reaction } from "mobx";
+
+setFlag(require, "mobx", "allowclient", true);
+setFlag(require, "preact", "allowclient", true);
+
+let globalConstructOrder = 0;
+
+export function observer<
+    T extends {
+        new(...args: any[]): {
+            render(): preact.ComponentChild;
+            forceUpdate(callback?: () => void): void;
+            componentWillUnmount?(): void;
+        }
+    }
+>(
+    Constructor: T
+) {
+    let name = Constructor.name;
+    return class extends Constructor {
+        // NOTE: This is completely valid javascript. For some reason (https://github.com/microsoft/TypeScript/pull/12065#issuecomment-270205513)
+        //  the typescript team decided, whatever, just make it an error, even though it isn't in es6 ("we should simplify ES6' semantics").
+        //  So, instead of simplifying ES6 semantics, lets give ourself better info for debugging...
+        // @ts-ignore
+        static get name() { return Constructor.name; }
+
+        // It is always true, that a parent has a constructOrder < a child's constructOrder
+        constructOrder = globalConstructOrder++;
+
+        reaction = new Reaction(`render.${name}.${this.constructOrder}`, () => {
+            super.forceUpdate();
+        });
+
+        componentWillUnmount() {
+            this.reaction.dispose();
+            super.componentWillUnmount?.();
+        }
+
+        render() {
+            let output: preact.ComponentChild;
+            this.reaction.track(() => {
+                output = super.render();
+            });
+            return output;
+        }
+    };
 }

package/mobx/promiseToObservable.tsx

@@ -1,41 +1,41 @@
-import { observable, Reaction, IObservable } from "mobx";
-import { cacheLimited } from "../src/caching";
-
-export interface InternalResult {
-    result: { value: unknown } | undefined;
-}
-export function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): { value: T | undefined } {
-    let isDone = false;
-    let error: unknown;
-    let result: T | undefined;
-
-    let internalResult: InternalResult = { result: undefined };
-
-    let isDoneTrigger = observable({
-        value: false
-    });
-    promise.then(
-        r => {
-            internalResult.result = { value: r };
-            result = r;
-            isDoneTrigger.value = true;
-            isDone = true;
-        },
-        e => {
-            error = e;
-            isDoneTrigger.value = true;
-            isDone = true;
-        }
-    );
-
-    return Object.assign({
-        get value() {
-            if (isDone) {
-                if (error) throw error;
-                return result;
-            }
-            isDoneTrigger.value;
-            return staleValue;
-        }
-    }, { internalResult });
-}
+import { observable, Reaction, IObservable } from "mobx";
+import { cacheLimited } from "../src/caching";
+
+export interface InternalResult {
+    result: { value: unknown } | undefined;
+}
+export function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): { value: T | undefined } {
+    let isDone = false;
+    let error: unknown;
+    let result: T | undefined;
+
+    let internalResult: InternalResult = { result: undefined };
+
+    let isDoneTrigger = observable({
+        value: false
+    });
+    promise.then(
+        r => {
+            internalResult.result = { value: r };
+            result = r;
+            isDoneTrigger.value = true;
+            isDone = true;
+        },
+        e => {
+            error = e;
+            isDoneTrigger.value = true;
+            isDone = true;
+        }
+    );
+
+    return Object.assign({
+        get value() {
+            if (isDone) {
+                if (error) throw error;
+                return result;
+            }
+            isDoneTrigger.value;
+            return staleValue;
+        }
+    }, { internalResult });
+}