@valbuild/language-server 0.98.0

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

@@ -0,0 +1,29 @@
+/**
+ * Lists the files a Val module may reference.
+ *
+ * Val stores referenced files under `/public/val` by convention (configurable
+ * via `files.directory` in val.config), and a reference is written as the path
+ * *including* the `/public` prefix — so this returns Val-style refs directly.
+ */
+/** Default directory, matching `files.directory` in val.config. */
+export declare const DEFAULT_FILES_DIRECTORY = "/public/val";
+export type PublicValFile = {
+    /** Val-style reference, for example `/public/val/images/logo.png`. */
+    ref: string;
+    /** Absolute path on disk. */
+    filePath: string;
+    /** Mime type derived from the extension, when recognised. */
+    mimeType?: string;
+};
+export type PublicValFiles = {
+    /** Files under `directory`, defaulting to the project's files directory. */
+    list(directory?: string): PublicValFile[];
+    /** As {@link list}, but only files whose mime type starts with `image/`. */
+    images(directory?: string): PublicValFile[];
+    invalidate(): void;
+};
+export declare function createPublicValFiles({ valRoot, directory, now, }: {
+    valRoot: string;
+    directory?: string;
+    now?: () => number;
+}): PublicValFiles;

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

@@ -0,0 +1,47 @@
+import { TextDocuments, type Connection, type InitializeParams } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { type ValClientCapabilities, type ValFeature, type ValInitializationOptions } from "./protocol.js";
+/**
+ * Everything resolved during `initialize` that the rest of the server needs.
+ * Held in one object so that later phases (diagnostics, completions, commands)
+ * have a single place to read session state from.
+ */
+export type ValSession = {
+    valRoot: string;
+    clientCapabilities: ValClientCapabilities;
+    protocolVersion: number;
+    features: ValFeature[];
+};
+/**
+ * Read and sanity-check the client's `initializationOptions`.
+ *
+ * A client that predates these options, or a bare LSP client such as a
+ * hand-written Neovim config, may send nothing useful. Rather than failing, we
+ * fall back to the workspace root and to the narrowest protocol range, so the
+ * server still starts.
+ */
+export declare function parseInitializationOptions(params: InitializeParams): ValInitializationOptions;
+/**
+ * Apply `VAL_*` overrides the client forwarded, so an editor session can be
+ * pointed at a non-production Val backend without restarting the editor with a
+ * modified environment.
+ */
+export declare function applyEnvOverrides(options: ValInitializationOptions): void;
+/**
+ * Wire up a Val language server on an existing connection.
+ *
+ * Split out from {@link main} so `main` stays a thin transport choice.
+ */
+export declare function createValLanguageServer(connection: Connection): {
+    documents: TextDocuments<TextDocument>;
+    /** Session state resolved during `initialize`; `undefined` until then. */
+    getSession: () => ValSession | undefined;
+};
+/**
+ * Entry point used by `bin.js`.
+ *
+ * `createConnection` picks its transport from argv (`--stdio`, `--node-ipc`,
+ * `--socket=`), so the same binary serves VS Code (IPC) and any other LSP
+ * client (stdio).
+ */
+export declare function main(): void;

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

@@ -0,0 +1,28 @@
+import type { ModuleFilePath } from "@valbuild/core";
+export declare function isValModuleUri(uri: string): boolean;
+/**
+ * `file:///a/b.val.ts` -> `/a/b.val.ts`
+ *
+ * Percent escapes are decoded, Windows drive letters lose the leading slash
+ * (`file:///c%3A/a` -> `c:/a`), and a URI with an authority is read as a UNC
+ * path (`file://host/share/a` -> `//host/share/a`). Anything that is not a
+ * `file:` URI is passed through unchanged, since callers also hand us plain
+ * paths.
+ */
+export declare function uriToPath(uri: string): string;
+/**
+ * `/a/b.val.ts` -> `file:///a/b.val.ts`
+ *
+ * The escaping matches what VS Code produces (drive-letter colons included), so
+ * that a URI built here can be looked up in the open-document map keyed by the
+ * URIs the client sent.
+ */
+export declare function pathToUri(fsPath: string): string;
+/**
+ * Convert a document URI into the `ModuleFilePath` Val addresses it by: a
+ * POSIX-style path relative to the Val root, with a leading slash.
+ *
+ * Returns `undefined` when the file lies outside the Val root — one server
+ * serves exactly one root, so another root's files are not its business.
+ */
+export declare function toModuleFilePath(valRoot: string, uri: string): ModuleFilePath | undefined;

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

@@ -0,0 +1,32 @@
+import ts from "typescript";
+import type { ModuleFilePath } from "@valbuild/core";
+/**
+ * Works out which Val modules a `val.modules.{ts,js}` file registers.
+ *
+ * Val only serves modules listed there, so an unregistered `.val.ts` file
+ * silently does nothing.
+ *
+ * Rather than pattern-matching the accepted authoring shapes — `config.modules([…])`
+ * vs `modules(config, […])`, bare `import("./x.val")` vs
+ * `{ def: () => import("./x.val") }` — this collects *every* dynamic import
+ * specifier in the file. That is deliberate:
+ *
+ *  - it covers all current shapes with one rule, and any shape added later;
+ *  - when in doubt it over-reports registration, so a new authoring form makes
+ *    the diagnostic go quiet rather than firing a false "missing module" on
+ *    every file, which is the failure mode that actually hurts.
+ */
+export declare function findRegisteredModuleSpecifiers(sourceFile: ts.SourceFile): string[];
+/**
+ * Whether `moduleFilePath` is registered by the given `val.modules` file.
+ *
+ * @param valModulesDir directory containing the val.modules file, relative to
+ *   the Val root (`""` when it sits at the root).
+ * @param moduleFilePath the module's path, Val-style: root-relative, leading
+ *   slash, with extension (for example `/content/page.val.ts`).
+ */
+export declare function isModuleRegistered({ sourceFile, valModulesDir, moduleFilePath, }: {
+    sourceFile: ts.SourceFile;
+    valModulesDir: string;
+    moduleFilePath: ModuleFilePath;
+}): boolean;

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

@@ -0,0 +1,10 @@
+/**
+ * Version of this package, read from its own package.json.
+ *
+ * Mirrors how `@valbuild/core` reports `Internal.VERSION.core`
+ * (see `packages/core/src/index.ts`): the built output lives one directory
+ * below the package root, so `../package.json` resolves correctly. Returns
+ * `null` rather than throwing if the file cannot be read — the version is only
+ * ever used for display, never for behaviour.
+ */
+export declare function getLanguageServerVersion(): string | null;

package/dist/valbuild-language-server.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsYnVpbGQtbGFuZ3VhZ2Utc2VydmVyLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi9kZWNsYXJhdGlvbnMvc3JjL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==