@valbuild/server 0.97.7 → 0.98.0

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

@@ -0,0 +1,20 @@
+import { FileMetadata, ImageMetadata, SerializedFileSchema, SerializedImageSchema } from "@valbuild/core";
+export declare function checkRemoteRef(remoteHost: string, ref: string, projectRoot: string, schema: SerializedImageSchema | SerializedFileSchema, metadata: Record<string, unknown> | undefined): Promise<{
+    status: "success";
+} | {
+    status: "fix-required";
+    metadata: ImageMetadata | FileMetadata;
+    ref: string;
+} | {
+    status: "error";
+    error: string;
+}>;
+export declare function getCachedRemoteFileDir(projectRoot: string): string;
+export declare function getCachedRemoteFilePath(fileExt: string, currentFileHash: string, remoteFileCacheDir: string): string;
+export declare function downloadFileFromRemote(ref: string, filePath: string): Promise<{
+    status: "success";
+    filePath: string;
+} | {
+    status: "error";
+    error: string;
+}>;

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

@@ -0,0 +1,17 @@
+import { ValConfig } from "@valbuild/core";
+/**
+ * Read and evaluate a `val.config.{ts,js}` file from disk.
+ *
+ * Returns `null` if the file does not exist, and throws if it exists but does
+ * not export a valid `config` object.
+ *
+ * Used by the Val CLI and by `@valbuild/language-server`, so that an editor
+ * resolves project config exactly the way the CLI does.
+ */
+export declare function evalValConfigFile(projectRoot: string, configFileName: string): Promise<ValConfig | null>;
+/**
+ * Resolve the project's Val config, trying the TypeScript file first and
+ * falling back to JavaScript. Mirrors what the CLI has always done at each of
+ * its call sites.
+ */
+export declare function findAndEvalValConfigFile(projectRoot: string): Promise<ValConfig | null>;

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

@@ -0,0 +1,4 @@
+import { FileMetadata, ImageMetadata } from "@valbuild/core";
+import { Buffer } from "buffer";
+export declare function extractImageMetadata(filename: string, input: Buffer): Promise<ImageMetadata>;
+export declare function extractFileMetadata(filename: string, _input: Buffer): Promise<FileMetadata>;

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

@@ -0,0 +1 @@
+export declare function getFileExt(filePath: string): string;

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

@@ -0,0 +1,2 @@
+import { ValidationError } from "@valbuild/core";
+export declare function getValidationErrorFileRef(validationError: ValidationError): string | null;

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

@@ -0,0 +1,5 @@
+import { SerializedSchema } from "@valbuild/core";
+/**
+ * Iterates through all schemas and find if there is 1 or more remote files in them
+ */
+export declare function hasRemoteFileSchema(schema: SerializedSchema): boolean;

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

@@ -8,12 +8,23 @@ export type { IValFSHost } from "./ValFSHost.js";
 export type { ValFS } from "./ValFS.js";
 export { patchSourceFile } from "./patchValFile.js";
 export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";
+export { analyzeValModule } from "./patch/ts/valModule.js";
+export type { ValModuleAnalysis } from "./patch/ts/valModule.js";
 export { createFixPatch } from "./createFixPatch.js";
 export * from "./jwt.js";
 export type { ValServer } from "./ValServer.js";
 export { getSettings } from "./getSettings.js";
 export { getPersonalAccessTokenPath, parsePersonalAccessTokenFile, } from "./personalAccessTokens.js";
 export { uploadRemoteFile } from "./uploadRemoteFile.js";
+export { extractImageMetadata, extractFileMetadata } from "./extractMetadata.js";
+export { validateMetadata } from "./validateMetadata.js";
+export { getValidationErrorFileRef } from "./getValidationErrorFileRef.js";
+export { checkRemoteRef, downloadFileFromRemote, getCachedRemoteFileDir, getCachedRemoteFilePath, } from "./checkRemoteRef.js";
+export { hasRemoteFileSchema } from "./hasRemoteFileSchema.js";
+export { getFileExt } from "./getFileExt.js";
+export { evalValConfigFile, findAndEvalValConfigFile, } from "./evalValConfigFile.js";
+export { startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, DEFAULT_LOGIN_HOST, DEFAULT_LOGIN_MAX_DURATION, DEFAULT_LOGIN_POLL_INTERVAL, } from "./login.js";
+export type { ValLoginErrorCode, ValLoginResult, ValLoginSession, } from "./login.js";
 export { createModulePathMap, getModulePathRange } from "./modulePathMap.js";
 export type { ModulePathMap } from "./modulePathMap.js";
 export { ValOpsFS } from "./ValOpsFS.js";

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

@@ -1,4 +1,14 @@
+import ts from "typescript";
 import type { ValModules } from "@valbuild/core";
+/**
+ * The filesystem seam `loadValModules` reads through.
+ *
+ * Defaults to `ts.sys`, i.e. the real filesystem. An editor integration (see
+ * `@valbuild/language-server`) passes a host that overlays unsaved buffers, so
+ * that evaluation sees what the user is looking at rather than what was last
+ * saved.
+ */
+export type ValModulesHost = ts.ParseConfigHost & ts.ModuleResolutionHost;
 /**
  * Loads the project's root `val.modules.ts` (or `.js`) using Node's `vm`
  * module and returns its default export (a `ValModules` registry).
@@ -20,4 +30,4 @@ import type { ValModules } from "@valbuild/core";
  * same trust level as running the project's build. It must never be used to
  * evaluate untrusted or third-party modules.
  */
-export declare function loadValModules(projectRoot: string): ValModules;
+export declare function loadValModules(projectRoot: string, host?: ValModulesHost): ValModules;

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

@@ -0,0 +1,69 @@
+/**
+ * The Val login device flow, as reusable primitives.
+ *
+ * The CLI wraps these with terminal output, and `@valbuild/language-server`
+ * wraps them with LSP `window/showDocument` and progress reporting. Neither the
+ * polling nor the token handling is duplicated between them.
+ *
+ * Deliberately no `console` output and no `process.exit`: every failure is a
+ * thrown {@link ValLoginError} so an embedder can decide how to surface it.
+ */
+export declare const DEFAULT_LOGIN_HOST = "https://admin.val.build";
+export type ValLoginErrorCode = 
+/** The server replied with something other than JSON. */
+"unexpected-content-type"
+/** The server replied with JSON, but not the shape we expect. */
+ | "unexpected-response"
+/** The server returned a 5xx. */
+ | "server-error"
+/** The user did not complete the login within the allotted time. */
+ | "timeout"
+/** The caller aborted the flow. */
+ | "aborted";
+export declare class ValLoginError extends Error {
+    readonly code: ValLoginErrorCode;
+    readonly details?: string | undefined;
+    constructor(code: ValLoginErrorCode, message: string, details?: string | undefined);
+}
+/** A login attempt that is waiting for the user to confirm in a browser. */
+export type ValLoginSession = {
+    /** Opaque token used to poll for confirmation. */
+    nonce: string;
+    /** URL the user must open to confirm the login. */
+    url: string;
+};
+export type ValLoginResult = {
+    profile: {
+        email: string;
+    };
+    pat: string;
+};
+/**
+ * Begin a login attempt. The caller is responsible for getting
+ * {@link ValLoginSession.url} in front of the user.
+ */
+export declare function startValLogin(options?: {
+    host?: string;
+}): Promise<ValLoginSession>;
+export declare const DEFAULT_LOGIN_MAX_DURATION: number;
+export declare const DEFAULT_LOGIN_POLL_INTERVAL = 1000;
+/**
+ * Poll until the user confirms the login in their browser.
+ *
+ * Accepts an `AbortSignal` so an editor can cancel the flow when the user
+ * dismisses the prompt, instead of leaving a poll loop running for 5 minutes.
+ */
+export declare function awaitValLoginConfirmation(nonce: string, options?: {
+    host?: string;
+    maxDurationMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+    /** Wall clock, injectable for tests. */
+    now?: () => number;
+}): Promise<ValLoginResult>;
+/**
+ * Write a completed login to the project's personal access token file.
+ *
+ * @returns the path the token was written to.
+ */
+export declare function persistPersonalAccessToken(projectRoot: string, result: ValLoginResult): string;

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

@@ -1,4 +1,8 @@
 import ts from "typescript";
+/**
+ * NOTE: `@valbuild/language-server` has a near-identical `modulePathMap.ts`.
+ * Fix traversal bugs in both, or fold them together.
+ */
 export type ModulePathMap = {
     [modulePath: string]: {
         children: ModulePathMap;

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

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

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

@@ -0,0 +1,6 @@
+import { FileMetadata, ImageMetadata } from "@valbuild/core";
+export declare function validateMetadata<Metadata extends ImageMetadata | FileMetadata>(actualMetadata: unknown, expectedMetadata: Metadata): false | {
+    missingMetadata?: (keyof Metadata)[];
+    erroneousMetadata?: Partial<Record<keyof Metadata, string>>;
+    globalErrors?: string[];
+};