@valbuild/server 0.13.11 → 0.15.0

package/dist/declarations/src/Service.d.ts

@@ -1,8 +1,8 @@
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { Patch } from "@valbuild/core/patch";
-import { ValSourceFileHandler } from "./ValSourceFileHandler";
-import { IValFSHost } from "./ValFSHost";
-import { SerializedModuleContent } from "./SerializedModuleContent";
+import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
+import { IValFSHost } from "./ValFSHost.js";
+import { SerializedModuleContent } from "./SerializedModuleContent.js";
 import { ModuleId, ModulePath } from "@valbuild/core";
 export type ServiceOptions = {
     /**

package/dist/declarations/src/ValFSHost.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ValFS } from "./ValFS";
+import { ValFS } from "./ValFS.js";
 /**
  * An implementation of methods in the various ts.*Host interfaces
  * that uses ValFS to resolve modules and read/write files.

package/dist/declarations/src/ValModuleLoader.d.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import type { IValFSHost } from "./ValFSHost";
-import { ValSourceFileHandler } from "./ValSourceFileHandler";
+import type { IValFSHost } from "./ValFSHost.js";
+import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 export declare const createModuleLoader: (rootDir: string, host?: IValFSHost) => ValModuleLoader;
 export declare class ValModuleLoader {
     readonly projectRoot: string;

package/dist/declarations/src/ValSourceFileHandler.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { IValFSHost } from "./ValFSHost";
+import { IValFSHost } from "./ValFSHost.js";
 export declare class ValSourceFileHandler {
     private readonly projectRoot;
     private readonly compilerOptions;

package/dist/declarations/src/createRequestHandler.d.ts

@@ -1,3 +1,3 @@
 import { RequestHandler } from "express";
-import { ValServer } from "./ValServer";
+import { ValServer } from "./ValServer.js";
 export declare function createRequestHandler(valServer: ValServer): RequestHandler;

package/dist/declarations/src/hosting.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { RequestListener } from "node:http";
-import { ServiceOptions } from "./Service";
+import { ServiceOptions } from "./Service.js";
 type Opts = ValServerOverrides & ServiceOptions;
 type ValServerOverrides = Partial<{
     /**

package/dist/declarations/src/index.d.ts

@@ -1,12 +1,12 @@
-export type { ServiceOptions } from "./Service";
-export { createService, Service } from "./Service";
-export { createRequestHandler } from "./createRequestHandler";
-export { createRequestListener } from "./hosting";
-export { ValModuleLoader } from "./ValModuleLoader";
-export { getCompilerOptions } from "./getCompilerOptions";
-export { ValSourceFileHandler } from "./ValSourceFileHandler";
-export { ValFSHost } from "./ValFSHost";
-export type { IValFSHost } from "./ValFSHost";
-export type { ValFS } from "./ValFS";
-export { patchSourceFile } from "./patchValFile";
-export { formatSyntaxErrorTree } from "./patch/ts/syntax";
+export type { ServiceOptions } from "./Service.js";
+export { createService, Service } from "./Service.js";
+export { createRequestHandler } from "./createRequestHandler.js";
+export { createRequestListener } from "./hosting.js";
+export { ValModuleLoader } from "./ValModuleLoader.js";
+export { getCompilerOptions } from "./getCompilerOptions.js";
+export { ValSourceFileHandler } from "./ValSourceFileHandler.js";
+export { ValFSHost } from "./ValFSHost.js";
+export type { IValFSHost } from "./ValFSHost.js";
+export type { ValFS } from "./ValFS.js";
+export { patchSourceFile } from "./patchValFile.js";
+export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";

package/dist/declarations/src/patchValFile.d.ts

@@ -1,9 +1,9 @@
 import { Patch, PatchError } from "@valbuild/core/patch";
 import { result } from "@valbuild/core/fp";
-import { type ValSyntaxErrorTree } from "./patch/ts/syntax";
-import { ValSourceFileHandler } from "./ValSourceFileHandler";
+import { type ValSyntaxErrorTree } from "./patch/ts/syntax.js";
+import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { QuickJSRuntime } from "quickjs-emscripten";
 import ts from "typescript";
-import { SerializedModuleContent } from "./SerializedModuleContent";
+import { SerializedModuleContent } from "./SerializedModuleContent.js";
 export declare const patchValFile: (id: string, valConfigPath: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<SerializedModuleContent>;
 export declare const patchSourceFile: (sourceFile: ts.SourceFile, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;

package/dist/valbuild-server.cjs.dev.js

@@ -824,22 +824,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
   runtime.setMemoryLimit(memoryLimit);
   runtime.setModuleLoader(modulePath => {
     try {
-      // Special cases for next package:
+      // Special cases to avoid loading the React packages since currently React does not have a ESM build:
       // TODO: this is not stable, find a better way to do this
-      if (modulePath === "./autoTagJSX") {
-        return {
-          value: ""
-        }; // ignore this module, it's only used in the browser
-      }
-
       if (modulePath === "@valbuild/react") {
         return {
           value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export function ValProvider() { throw Error(`Cannot use 'ValProvider' in this type of file`) }; export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
         };
       }
-      if (modulePath === "./ValRichText") {
+      if (modulePath === "@valbuild/react/stega") {
         return {
-          value: "export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
+          value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };"
         };
       }
       return {
@@ -847,22 +841,17 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
       };
     } catch (e) {
       return {
-        error: Error(`Could not resolve module: ${modulePath}'`)
+        error: Error(`Could not resolve module: '${modulePath}': `)
       };
     }
   }, (baseModuleName, requestedName) => {
     try {
-      if (requestedName === "./autoTagJSX") {
-        return {
-          value: requestedName
-        };
-      }
       if (requestedName === "@valbuild/react") {
         return {
           value: requestedName
         };
       }
-      if (requestedName === "./ValRichText") {
+      if (requestedName === "@valbuild/react/stega") {
         return {
           value: requestedName
         };

package/dist/valbuild-server.cjs.prod.js

@@ -824,22 +824,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
   runtime.setMemoryLimit(memoryLimit);
   runtime.setModuleLoader(modulePath => {
     try {
-      // Special cases for next package:
+      // Special cases to avoid loading the React packages since currently React does not have a ESM build:
       // TODO: this is not stable, find a better way to do this
-      if (modulePath === "./autoTagJSX") {
-        return {
-          value: ""
-        }; // ignore this module, it's only used in the browser
-      }
-
       if (modulePath === "@valbuild/react") {
         return {
           value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export function ValProvider() { throw Error(`Cannot use 'ValProvider' in this type of file`) }; export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
         };
       }
-      if (modulePath === "./ValRichText") {
+      if (modulePath === "@valbuild/react/stega") {
         return {
-          value: "export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
+          value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };"
         };
       }
       return {
@@ -847,22 +841,17 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
       };
     } catch (e) {
       return {
-        error: Error(`Could not resolve module: ${modulePath}'`)
+        error: Error(`Could not resolve module: '${modulePath}': `)
       };
     }
   }, (baseModuleName, requestedName) => {
     try {
-      if (requestedName === "./autoTagJSX") {
-        return {
-          value: requestedName
-        };
-      }
       if (requestedName === "@valbuild/react") {
         return {
           value: requestedName
         };
       }
-      if (requestedName === "./ValRichText") {
+      if (requestedName === "@valbuild/react/stega") {
         return {
           value: requestedName
         };

package/dist/valbuild-server.esm.js

@@ -811,22 +811,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
   runtime.setMemoryLimit(memoryLimit);
   runtime.setModuleLoader(modulePath => {
     try {
-      // Special cases for next package:
+      // Special cases to avoid loading the React packages since currently React does not have a ESM build:
       // TODO: this is not stable, find a better way to do this
-      if (modulePath === "./autoTagJSX") {
-        return {
-          value: ""
-        }; // ignore this module, it's only used in the browser
-      }
-
       if (modulePath === "@valbuild/react") {
         return {
           value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export function ValProvider() { throw Error(`Cannot use 'ValProvider' in this type of file`) }; export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
         };
       }
-      if (modulePath === "./ValRichText") {
+      if (modulePath === "@valbuild/react/stega") {
         return {
-          value: "export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};"
+          value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };"
         };
       }
       return {
@@ -834,22 +828,17 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
       };
     } catch (e) {
       return {
-        error: Error(`Could not resolve module: ${modulePath}'`)
+        error: Error(`Could not resolve module: '${modulePath}': `)
       };
     }
   }, (baseModuleName, requestedName) => {
     try {
-      if (requestedName === "./autoTagJSX") {
-        return {
-          value: requestedName
-        };
-      }
       if (requestedName === "@valbuild/react") {
         return {
           value: requestedName
         };
       }
-      if (requestedName === "./ValRichText") {
+      if (requestedName === "@valbuild/react/stega") {
         return {
           value: requestedName
         };

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.13.11",
+  "version": "0.15.0",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",
@@ -25,8 +25,8 @@
     "concurrently": "^7.6.0"
   },
   "dependencies": {
-    "@valbuild/core": "~0.13.4",
-    "@valbuild/ui": "~0.13.4",
+    "@valbuild/core": "~0.15.0",
+    "@valbuild/ui": "~0.15.0",
     "express": "^4.18.2",
     "quickjs-emscripten": "^0.21.1",
     "ts-morph": "^17.0.1",

package/src/ValQuickJSRuntime.ts

@@ -20,40 +20,33 @@ export async function newValQuickJSRuntime(
   runtime.setModuleLoader(
     (modulePath) => {
       try {
-        // Special cases for next package:
+        // Special cases to avoid loading the React packages since currently React does not have a ESM build:
         // TODO: this is not stable, find a better way to do this
-        if (modulePath === "./autoTagJSX") {
-          return { value: "" }; // ignore this module, it's only used in the browser
-        }
         if (modulePath === "@valbuild/react") {
           return {
             value:
               "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export function ValProvider() { throw Error(`Cannot use 'ValProvider' in this type of file`) }; export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};",
           };
         }
-
-        if (modulePath === "./ValRichText") {
+        if (modulePath === "@valbuild/react/stega") {
           return {
             value:
-              "export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};",
+              "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };",
           };
         }
         return { value: moduleLoader.getModule(modulePath) };
       } catch (e) {
         return {
-          error: Error(`Could not resolve module: ${modulePath}'`),
+          error: Error(`Could not resolve module: '${modulePath}': `),
         };
       }
     },
     (baseModuleName, requestedName): JSModuleNormalizeResult => {
       try {
-        if (requestedName === "./autoTagJSX") {
-          return { value: requestedName };
-        }
         if (requestedName === "@valbuild/react") {
           return { value: requestedName };
         }
-        if (requestedName === "./ValRichText") {
+        if (requestedName === "@valbuild/react/stega") {
           return { value: requestedName };
         }
         const modulePath = moduleLoader.resolveModulePath(

package/dist/declarations/src/LocalValServer.d.ts

@@ -1,22 +0,0 @@
-import express from "express";
-import { Service } from "./Service";
-import { ValServer } from "./ValServer";
-export type LocalValServerOptions = {
-    service: Service;
-};
-export declare class LocalValServer implements ValServer {
-    readonly options: LocalValServerOptions;
-    constructor(options: LocalValServerOptions);
-    session(_req: express.Request, res: express.Response): Promise<void>;
-    getIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    patchIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    private badRequest;
-    commit(req: express.Request, res: express.Response): Promise<void>;
-    authorize(req: express.Request, res: express.Response): Promise<void>;
-    callback(req: express.Request, res: express.Response): Promise<void>;
-    logout(req: express.Request, res: express.Response): Promise<void>;
-}

package/dist/declarations/src/ProxyValServer.d.ts

@@ -1,52 +0,0 @@
-import express from "express";
-import { ValServer } from "./ValServer";
-import { z } from "zod";
-export type ProxyValServerOptions = {
-    apiKey: string;
-    route: string;
-    valSecret: string;
-    valBuildUrl: string;
-    gitCommit: string;
-    gitBranch: string;
-};
-export declare class ProxyValServer implements ValServer {
-    readonly options: ProxyValServerOptions;
-    constructor(options: ProxyValServerOptions);
-    authorize(req: express.Request, res: express.Response): Promise<void>;
-    callback(req: express.Request, res: express.Response): Promise<void>;
-    logout(_req: express.Request, res: express.Response): Promise<void>;
-    withAuth<T>(req: express.Request, res: express.Response, handler: (data: IntegratedServerJwtPayload) => Promise<T>): Promise<T | undefined>;
-    session(req: express.Request, res: express.Response): Promise<void>;
-    getIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    patchIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    commit(req: express.Request, res: express.Response): Promise<void>;
-    private getAuthHeaders;
-    private consumeCode;
-    private getAuthorizeUrl;
-    private getAppErrorUrl;
-}
-declare const IntegratedServerJwtPayload: z.ZodObject<{
-    sub: z.ZodString;
-    exp: z.ZodNumber;
-    token: z.ZodString;
-    org: z.ZodString;
-    project: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    project: string;
-    sub: string;
-    exp: number;
-    token: string;
-    org: string;
-}, {
-    project: string;
-    sub: string;
-    exp: number;
-    token: string;
-    org: string;
-}>;
-export type IntegratedServerJwtPayload = z.infer<typeof IntegratedServerJwtPayload>;
-export {};

package/dist/declarations/src/ValQuickJSRuntime.d.ts

@@ -1,7 +0,0 @@
-import { QuickJSWASMModule } from "quickjs-emscripten";
-import { ValModuleLoader } from "./ValModuleLoader";
-export declare function newValQuickJSRuntime(quickJSModule: Pick<QuickJSWASMModule, "newRuntime">, moduleLoader: ValModuleLoader, { maxStackSize, // TODO: these were randomly chosen, we should figure out what the right values are:
-memoryLimit, }?: {
-    maxStackSize?: number;
-    memoryLimit?: number;
-}): Promise<import("quickjs-emscripten").QuickJSRuntime>;

package/dist/declarations/src/expressHelpers.d.ts

@@ -1,4 +0,0 @@
-import { SourcePath } from "@valbuild/core/src/val";
-export declare function getPathFromParams(params: {
-    0: string;
-}): SourcePath;

package/dist/declarations/src/jwt.d.ts

@@ -1,3 +0,0 @@
-export declare function decodeJwt(token: string, secretKey?: string): unknown | null;
-export declare function getExpire(): number;
-export declare function encodeJwt(payload: object, sessionKey: string): string;

package/dist/declarations/src/patch/ts/ops.d.ts

@@ -1,27 +0,0 @@
-import ts from "typescript";
-import { result, array } from "@valbuild/core/fp";
-import { ValSyntaxErrorTree } from "./syntax";
-import { Ops, PatchError, JSONValue } from "@valbuild/core/patch";
-type TSOpsResult<T> = result.Result<T, PatchError | ValSyntaxErrorTree>;
-declare module "typescript" {
-    interface PrinterOptions {
-        /**
-         * Internal option that stops printing unnecessary ASCII escape sequences
-         * in strings, though it might have unintended effects. Might be useful?
-         */
-        neverAsciiEscape?: boolean;
-    }
-}
-export declare function getFromNode(node: ts.Expression, key: string): TSOpsResult<ts.Expression | undefined>;
-export declare class TSOps implements Ops<ts.SourceFile, ValSyntaxErrorTree> {
-    private findRoot;
-    constructor(findRoot: (document: ts.SourceFile) => result.Result<ts.Expression, ValSyntaxErrorTree>);
-    get(document: ts.SourceFile, path: string[]): TSOpsResult<JSONValue>;
-    add(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<ts.SourceFile>;
-    remove(document: ts.SourceFile, path: array.NonEmptyArray<string>): TSOpsResult<ts.SourceFile>;
-    replace(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<ts.SourceFile>;
-    move(document: ts.SourceFile, from: array.NonEmptyArray<string>, path: string[]): TSOpsResult<ts.SourceFile>;
-    copy(document: ts.SourceFile, from: string[], path: string[]): TSOpsResult<ts.SourceFile>;
-    test(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<boolean>;
-}
-export {};

package/dist/declarations/src/patch/ts/valModule.d.ts

@@ -1,8 +0,0 @@
-import ts from "typescript";
-import { result } from "@valbuild/core/fp";
-import { ValSyntaxErrorTree } from "./syntax";
-export type ValModuleAnalysis = {
-    schema: ts.Expression;
-    source: ts.Expression;
-};
-export declare function analyzeValModule(sourceFile: ts.SourceFile): result.Result<ValModuleAnalysis, ValSyntaxErrorTree>;

package/dist/declarations/src/patch/validation.d.ts

@@ -1,4 +0,0 @@
-import type { PatchJSON as PatchJSONT } from "@valbuild/core/patch";
-import z from "zod";
-export declare const PatchJSON: z.ZodType<PatchJSONT>;
-export type PatchJSON = PatchJSONT;

package/dist/declarations/src/readValFile.d.ts

@@ -1,3 +0,0 @@
-import { QuickJSRuntime } from "quickjs-emscripten";
-import { SerializedModuleContent } from "./SerializedModuleContent";
-export declare const readValFile: (id: string, valConfigPath: string, runtime: QuickJSRuntime) => Promise<SerializedModuleContent>;