socket-function 0.165.0 → 1.0.1

package/SocketFunction.d.ts

@@ -1,6 +1,5 @@
 /// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
-/// <reference types="node" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";

package/index.d.ts

@@ -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" />
@@ -207,7 +317,6 @@ declare module "socket-function/require/compileFlags" {
 }
 
 declare module "socket-function/require/extMapper" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function getExtContentType(ext: string): string;
     export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
@@ -233,7 +342,6 @@ declare module "socket-function/require/require" {
 }
 
 declare module "socket-function/src/CallFactory" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import { CallType } from "../SocketFunctionTypes";
@@ -274,7 +382,6 @@ declare module "socket-function/src/CallFactory" {
 }
 
 declare module "socket-function/src/JSONLACKS/JSONLACKS" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export interface JSONLACKS_ParseConfig {
         extended?: boolean;
@@ -421,7 +528,6 @@ declare module "socket-function/src/caching" {
 }
 
 declare module "socket-function/src/callHTTPHandler" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import http from "http";
@@ -476,7 +582,6 @@ declare module "socket-function/src/callManager" {
 }
 
 declare module "socket-function/src/certStore" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /** Must be populated before the server starts */
     export declare function trustCertificate(cert: string | Buffer): void;
@@ -590,7 +695,6 @@ declare module "socket-function/src/forwardPort" {
 }
 
 declare module "socket-function/src/https" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
         headers?: {
@@ -602,7 +706,6 @@ declare module "socket-function/src/https" {
 }
 
 declare module "socket-function/src/misc" {
-    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "./types";
     export declare const timeInSecond = 1000;
@@ -1013,7 +1116,6 @@ declare module "socket-function/src/storagePath" {
 }
 
 declare module "socket-function/src/tlsParsing" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function parseTLSHello(buffer: Buffer): {
         extensions: {
@@ -1038,7 +1140,6 @@ declare module "socket-function/src/types" {
 }
 
 declare module "socket-function/src/webSocketServer" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import https from "https";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.165.0",
+	"version": "1.0.1",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -11,7 +11,7 @@
 		"pako": "^2.1.0",
 		"preact": "10.24.3",
 		"typedev": "^0.4.0",
-		"typenode": "^5.13.0",
+		"typenode": "^6.0.1",
 		"ws": "^8.17.1"
 	},
 	"types": "index.d.ts",

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> = {

package/require/extMapper.d.ts

@@ -1,4 +1,3 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function getExtContentType(ext: string): string;
 export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;

package/src/CallFactory.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import { CallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import * as tls from "tls";

package/src/JSONLACKS/JSONLACKS.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export interface JSONLACKS_ParseConfig {
     extended?: boolean;
     discardMissingReferences?: boolean;

package/src/callHTTPHandler.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import http from "http";
 import { CallType } from "../SocketFunctionTypes";
 export declare function setDefaultHTTPCall(call: CallType): void;

package/src/certStore.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 /** Must be populated before the server starts */
 export declare function trustCertificate(cert: string | Buffer): void;
 export declare function getTrustedCertificates(): string[];

package/src/https.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
     headers?: {
         [key: string]: string | undefined;

package/src/misc.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare const timeInSecond = 1000;
 export declare const timeInMinute: number;

package/src/tlsParsing.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function parseTLSHello(buffer: Buffer): {
     extensions: {
         type: number;

package/src/webSocketServer.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import https from "https";
 import { Watchable } from "./misc";
 export type SocketServerConfig = (https.ServerOptions & {