socket-function 1.0.0 → 1.0.2

package/generateIndexDts.js

@@ -24,20 +24,27 @@ function generateIndexDts() {
     const renderUtilsPath = __dirname;
     const dtsFiles = getAllDtsFiles(renderUtilsPath);
 
+    const excludedModules = ["socket-function/SocketFunction", "socket-function/index"];
+
     const modules = dtsFiles
-        .filter(filePath => {
-            // Exclude SocketFunction.d.ts and index.d.ts from being wrapped in a module declaration
-            const relativePath = path.relative(renderUtilsPath, filePath);
-            const withoutExt = relativePath.replace(/\.d\.ts$/, "");
-            const modulePath = "socket-function/" + withoutExt.replace(/\\/g, "/");
-            return modulePath !== "socket-function/SocketFunction" && modulePath !== "socket-function/index";
-        })
         .map(filePath => {
             const relativePath = path.relative(renderUtilsPath, filePath);
             const withoutExt = relativePath.replace(/\.d\.ts$/, "");
             const modulePath = "socket-function/" + withoutExt.replace(/\\/g, "/");
+            if (excludedModules.includes(modulePath)) return undefined;
+
+            let content = fs.readFileSync(filePath, "utf8");
+
+            // Resolve relative imports to absolute module paths
+            const moduleDir = path.dirname(modulePath);
+            content = content.replace(
+                /(import|export)\s+([^"']*)\s+from\s+["'](\.[^"']+)["']/g,
+                (match, keyword, imported, relativeImport) => {
+                    const absoluteModulePath = path.join(moduleDir, relativeImport).replace(/\\/g, "/");
+                    return `${keyword} ${imported} from "${absoluteModulePath}"`;
+                }
+            );
 
-            const content = fs.readFileSync(filePath, "utf8");
             const indentedContent = content
                 .split("\n")
                 .map(line => line ? "    " + line : line)
@@ -45,6 +52,7 @@ function generateIndexDts() {
 
             return `declare module "${modulePath}" {\n${indentedContent}\n}`;
         })
+        .filter(x => x)
         .sort()
         .join("\n\n");
 

package/index.d.ts

@@ -8,8 +8,8 @@ declare module "socket-function/SetProcessVariables" {
 
 declare module "socket-function/SocketFunctionTypes" {
     /// <reference path="require/RequireController.d.ts" />
-    import { getCallObj } from "./src/nodeProxy";
-    import { Args, MaybePromise } from "./src/types";
+    import { getCallObj } from "socket-function/src/nodeProxy";
+    import { Args, MaybePromise } from "socket-function/src/types";
     export declare const socket: unique symbol;
     export type SocketExposedInterface = {
         [functionName: string]: (...args: any[]) => Promise<unknown>;
@@ -191,6 +191,116 @@ declare module "socket-function/require/CSSShim" {
 
 }
 
+declare module "socket-function/require/RequireController" {
+    /// <reference path="../../typenode/index.d.ts" />
+    /// <reference types="node" />
+    declare global {
+        namespace NodeJS {
+            interface Module {
+                /** Indicates the module is allowed clientside.
+                 *  NOTE: Set with `module.allowclient = true`. HOWEVER, access via getIsAllowClient, which will check
+                 */
+                allowclient?: boolean;
+                /** Causes the module to not preload, requiring `await import()` for it to load correctly
+                 *      - Shouldn't be set recursively, otherwise nested packages will break.
+                 */
+                lazyload?: boolean;
+                /** Indicates the module is definitely not allowed clientside */
+                serveronly?: boolean;
+                /** Used internally by RequireController */
+                requireControllerSeqNum?: number;
+                evalStartTime?: number;
+                evalEndTime?: number;
+                /** (Presently only called by require.js)
+                 *      Called on require calls, to allow providers to create custom exports depending on the caller.
+                 *          - Mostly used to allow functions to know the calling module.
+                 */
+                remapExports?: (exports: {
+                    [key: string]: unknown;
+                }, callerModule: NodeJS.Module) => {
+                    [key: string]: unknown;
+                };
+                /** Only set if clientside (and allowed clientside) */
+                source?: string;
+            }
+        }
+        interface Window {
+            clientsideBootTime: number;
+        }
+        var suppressUnexpectedModuleWarning: number | undefined;
+    }
+    /** Imports it, serverside, delayed. For dynamic imports, which we need to include once, but don't want to include
+     *      immediately (due to cyclic issues), and isn't included initially.
+     */
+    export declare function lazyImport(getModule: () => Promise<unknown>): void;
+    declare const requireSeqNumProcessId: string;
+    declare function injectHTMLBeforeStartup(text: string | (() => Promise<string>)): void;
+    declare function addStaticRoot(root: string): void;
+    type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
+    export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
+    declare let mapGetModules: {
+        remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+    }[];
+    declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
+    declare class RequireControllerBase {
+        rootResolvePath: string;
+        requireHTML(config?: {
+            requireCalls?: string[];
+            cacheTime?: number;
+        }): Promise<Buffer>;
+        getModules(pathRequests: string[], alreadyHave?: {
+            requireSeqNumProcessId: string;
+            seqNumRanges: {
+                s: number;
+                e?: number;
+            }[];
+        }, config?: {}): Promise<{
+            requestsResolvedPaths: string[];
+            modules: {
+                [resolvedPath: string]: SerializedModule;
+            };
+            requireSeqNumProcessId: string;
+        }>;
+    }
+    export declare function getIsAllowClient(module: NodeJS.Module): boolean | undefined;
+    type ClientRemapCallback = (args: GetModulesArgs) => Promise<GetModulesArgs>;
+    declare global {
+        /** Must be set clientside BEFORE requests are made (so you likely want to use RequireController.addMapGetModules
+         *      to inject code that will use this) */
+        var remapImportRequestsClientside: undefined | ClientRemapCallback[];
+    }
+    /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
+    export declare function setRequireBootRequire(dir: string): void;
+    export declare function allowAllNodeModules(): void;
+    export declare const RequireController: import("../SocketFunctionTypes").SocketRegistered<{
+        rootResolvePath: "Function has implementation but is not exposed in the SocketFunction.register call";
+        requireHTML: (config?: {
+            requireCalls?: string[];
+            cacheTime?: number;
+        }) => Promise<Buffer>;
+        getModules: (pathRequests: string[], alreadyHave?: {
+            requireSeqNumProcessId: string;
+            seqNumRanges: {
+                s: number;
+                e?: number;
+            }[];
+        }, config?: {}) => Promise<{
+            requestsResolvedPaths: string[];
+            modules: {
+                [resolvedPath: string]: SerializedModule;
+            };
+            requireSeqNumProcessId: string;
+        }>;
+    }> & {
+        injectHTMLBeforeStartup: typeof injectHTMLBeforeStartup;
+        addMapGetModules: typeof addMapGetModules;
+        addStaticRoot: typeof addStaticRoot;
+        allowAllNodeModules: typeof allowAllNodeModules;
+    };
+    export {};
+
+}
+
 declare module "socket-function/require/compileFlags" {
     /// <reference path="RequireController.d.ts" />
     /// <reference types="node" />
@@ -234,7 +344,7 @@ declare module "socket-function/require/require" {
 declare module "socket-function/src/CallFactory" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { CallType } from "../SocketFunctionTypes";
+    import { CallType } from "socket-function/SocketFunctionTypes";
     import * as ws from "ws";
     import * as tls from "tls";
     export interface CallFactory {
@@ -320,7 +430,7 @@ declare module "socket-function/src/args" {
 }
 
 declare module "socket-function/src/batching" {
-    import { AnyFunction } from "./types";
+    import { AnyFunction } from "socket-function/src/types";
     export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
     export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
     export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
@@ -355,7 +465,7 @@ declare module "socket-function/src/batching" {
 }
 
 declare module "socket-function/src/caching" {
-    import { AnyFunction, Args } from "./types";
+    import { AnyFunction, Args } from "socket-function/src/types";
     export declare function lazy<T>(factory: () => T): {
         (): T;
         reset(): void;
@@ -421,7 +531,7 @@ declare module "socket-function/src/callHTTPHandler" {
     /// <reference types="node" />
     /// <reference types="node" />
     import http from "http";
-    import { CallType } from "../SocketFunctionTypes";
+    import { CallType } from "socket-function/SocketFunctionTypes";
     export declare function setDefaultHTTPCall(call: CallType): void;
     export declare function getServerLocationFromRequest(request: http.IncomingMessage): {
         address: string;
@@ -448,7 +558,7 @@ declare module "socket-function/src/callHTTPHandler" {
 
 declare module "socket-function/src/callManager" {
     /// <reference path="../hot/HotReloadController.d.ts" />
-    import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+    import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "socket-function/SocketFunctionTypes";
     export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
     export declare function shouldCompressCall(call: CallType): boolean;
     export declare function performLocalCall(config: {
@@ -597,7 +707,7 @@ declare module "socket-function/src/https" {
 
 declare module "socket-function/src/misc" {
     /// <reference types="node" />
-    import { MaybePromise } from "./types";
+    import { MaybePromise } from "socket-function/src/types";
     export declare const timeInSecond = 1000;
     export declare const timeInMinute: number;
     export declare const timeInHour: number;
@@ -712,8 +822,8 @@ declare module "socket-function/src/networking" {
 }
 
 declare module "socket-function/src/nodeCache" {
-    import { CallFactory } from "./CallFactory";
-    import { MaybePromise } from "./types";
+    import { CallFactory } from "socket-function/src/CallFactory";
+    import { MaybePromise } from "socket-function/src/types";
     export declare function getNodeId(domain: string, port: number): string;
     /** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
     export declare function getNodeIdFromLocation(): string;
@@ -740,7 +850,7 @@ declare module "socket-function/src/nodeCache" {
 }
 
 declare module "socket-function/src/nodeProxy" {
-    import { FullCallType, SocketInternalInterface } from "../SocketFunctionTypes";
+    import { FullCallType, SocketInternalInterface } from "socket-function/SocketFunctionTypes";
     type CallProxyType = {
         [nodeId: string]: SocketInternalInterface;
     };
@@ -767,7 +877,7 @@ declare module "socket-function/src/profiling/getOwnTime" {
 }
 
 declare module "socket-function/src/profiling/measure" {
-    import { StatsValue } from "./stats";
+    import { StatsValue } from "socket-function/src/profiling/stats";
     /** NOTE: Must be called BEFORE anything else is imported!
      *      NOTE: Measurements on on by default now, so this doesn't really need to be called...
     */
@@ -888,7 +998,7 @@ declare module "socket-function/src/profiling/stats" {
 }
 
 declare module "socket-function/src/profiling/statsFormat" {
-    import { StatsValue } from "./stats";
+    import { StatsValue } from "socket-function/src/profiling/stats";
     export declare function percent(value: number): string;
     export declare function formatStats(stats: StatsValue, config?: {
         noColor?: boolean;
@@ -1033,7 +1143,7 @@ declare module "socket-function/src/webSocketServer" {
     /// <reference types="node" />
     /// <reference types="node" />
     import https from "https";
-    import { Watchable } from "./misc";
+    import { Watchable } from "socket-function/src/misc";
     export type SocketServerConfig = (https.ServerOptions & {
         key: string | Buffer;
         cert: string | Buffer;
@@ -1065,7 +1175,7 @@ declare module "socket-function/src/webSocketServer" {
 declare module "socket-function/src/websocketFactory" {
     /// <reference types="node" />
     import tls from "tls";
-    import { SenderInterface } from "./CallFactory";
+    import { SenderInterface } from "socket-function/src/CallFactory";
     import type * as ws from "ws";
     export declare function getTLSSocket(webSocket: ws.WebSocket): tls.TLSSocket;
     /** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/RequireController.d.ts

@@ -0,0 +1,106 @@
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference types="node" />
+declare global {
+    namespace NodeJS {
+        interface Module {
+            /** Indicates the module is allowed clientside.
+             *  NOTE: Set with `module.allowclient = true`. HOWEVER, access via getIsAllowClient, which will check
+             */
+            allowclient?: boolean;
+            /** Causes the module to not preload, requiring `await import()` for it to load correctly
+             *      - Shouldn't be set recursively, otherwise nested packages will break.
+             */
+            lazyload?: boolean;
+            /** Indicates the module is definitely not allowed clientside */
+            serveronly?: boolean;
+            /** Used internally by RequireController */
+            requireControllerSeqNum?: number;
+            evalStartTime?: number;
+            evalEndTime?: number;
+            /** (Presently only called by require.js)
+             *      Called on require calls, to allow providers to create custom exports depending on the caller.
+             *          - Mostly used to allow functions to know the calling module.
+             */
+            remapExports?: (exports: {
+                [key: string]: unknown;
+            }, callerModule: NodeJS.Module) => {
+                [key: string]: unknown;
+            };
+            /** Only set if clientside (and allowed clientside) */
+            source?: string;
+        }
+    }
+    interface Window {
+        clientsideBootTime: number;
+    }
+    var suppressUnexpectedModuleWarning: number | undefined;
+}
+/** Imports it, serverside, delayed. For dynamic imports, which we need to include once, but don't want to include
+ *      immediately (due to cyclic issues), and isn't included initially.
+ */
+export declare function lazyImport(getModule: () => Promise<unknown>): void;
+declare const requireSeqNumProcessId: string;
+declare function injectHTMLBeforeStartup(text: string | (() => Promise<string>)): void;
+declare function addStaticRoot(root: string): void;
+type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
+export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
+declare let mapGetModules: {
+    remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+}[];
+declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
+declare class RequireControllerBase {
+    rootResolvePath: string;
+    requireHTML(config?: {
+        requireCalls?: string[];
+        cacheTime?: number;
+    }): Promise<Buffer>;
+    getModules(pathRequests: string[], alreadyHave?: {
+        requireSeqNumProcessId: string;
+        seqNumRanges: {
+            s: number;
+            e?: number;
+        }[];
+    }, config?: {}): Promise<{
+        requestsResolvedPaths: string[];
+        modules: {
+            [resolvedPath: string]: SerializedModule;
+        };
+        requireSeqNumProcessId: string;
+    }>;
+}
+export declare function getIsAllowClient(module: NodeJS.Module): boolean | undefined;
+type ClientRemapCallback = (args: GetModulesArgs) => Promise<GetModulesArgs>;
+declare global {
+    /** Must be set clientside BEFORE requests are made (so you likely want to use RequireController.addMapGetModules
+     *      to inject code that will use this) */
+    var remapImportRequestsClientside: undefined | ClientRemapCallback[];
+}
+/** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
+export declare function setRequireBootRequire(dir: string): void;
+export declare function allowAllNodeModules(): void;
+export declare const RequireController: import("../SocketFunctionTypes").SocketRegistered<{
+    rootResolvePath: "Function has implementation but is not exposed in the SocketFunction.register call";
+    requireHTML: (config?: {
+        requireCalls?: string[];
+        cacheTime?: number;
+    }) => Promise<Buffer>;
+    getModules: (pathRequests: string[], alreadyHave?: {
+        requireSeqNumProcessId: string;
+        seqNumRanges: {
+            s: number;
+            e?: number;
+        }[];
+    }, config?: {}) => Promise<{
+        requestsResolvedPaths: string[];
+        modules: {
+            [resolvedPath: string]: SerializedModule;
+        };
+        requireSeqNumProcessId: string;
+    }>;
+}> & {
+    injectHTMLBeforeStartup: typeof injectHTMLBeforeStartup;
+    addMapGetModules: typeof addMapGetModules;
+    addStaticRoot: typeof addStaticRoot;
+    allowAllNodeModules: typeof allowAllNodeModules;
+};
+export {};

package/require/RequireController.ts

@@ -115,7 +115,7 @@ class RequireControllerBase {
     public async requireHTML(config?: {
         requireCalls?: string[];
         cacheTime?: number;
-    }) {
+    }): Promise<Buffer> {
         let { requireCalls, cacheTime } = config || {};
         let httpRequest = getCurrentHTTPRequest();
         let headers: Record<string, string> = {