qsharp-lang 1.6.0 → 1.6.2-dev

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import * as wasm from "../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../lib/web/qsc_wasm.js";
+import { IProjectHost, TargetProfile } from "../lib/web/qsc_wasm.js";
 import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
 import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
 import { ILanguageService, ILanguageServiceWorker, qsharpLibraryUriScheme } from "./language-service/language-service.js";
@@ -8,22 +8,17 @@ export { qsharpLibraryUriScheme };
 export declare function loadWasmModule(uriOrBuffer: string | ArrayBuffer): Promise<void>;
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
 export declare function getDebugService(): Promise<IDebugService>;
-export declare function getProjectLoader(readFile: (path: string) => Promise<string | null>, loadDirectory: (path: string) => Promise<[string, number][]>, getManifest: (path: string) => Promise<{
-    manifestDirectory: string;
-} | null>): Promise<wasm.ProjectLoader>;
+export declare function getProjectLoader(host: IProjectHost): Promise<wasm.ProjectLoader>;
 export declare function getDebugServiceWorker(worker: string | Worker): IDebugServiceWorker;
 export declare function getCompiler(): Promise<ICompiler>;
 export declare function getCompilerWorker(worker: string | Worker): ICompilerWorker;
-export declare function getLanguageService(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
-    manifestDirectory: string;
-} | null>): Promise<ILanguageService>;
+export declare function getLanguageService(host?: IProjectHost): Promise<ILanguageService>;
 export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
 export { StepResultId } from "../lib/web/qsc_wasm.js";
-export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IQSharpError, IRange, IStackFrame, IWorkspaceEdit, IStructStepResult, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
 export { type Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState, type ProgramConfig } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";
-export { getAllKatas, getExerciseSources, getKata, type ContentItem, type Example, type Exercise, type ExplainedSolution, type ExplainedSolutionItem, type Kata, type KataSection, type Lesson, type LessonItem, type Question, } from "./katas.js";
 export { type LanguageServiceEvent } from "./language-service/language-service.js";
 export { default as samples } from "./samples.generated.js";
 export { log, type LogLevel, type TargetProfile };

package/dist/browser.js

@@ -71,9 +71,9 @@ export async function getDebugService() {
     await instantiateWasm();
     return new QSharpDebugService(wasm);
 }
-export async function getProjectLoader(readFile, loadDirectory, getManifest) {
+export async function getProjectLoader(host) {
     await instantiateWasm();
-    return new wasm.ProjectLoader(readFile, loadDirectory, getManifest);
+    return new wasm.ProjectLoader(host);
 }
 // Create the debugger inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
@@ -95,9 +95,9 @@ export function getCompilerWorker(worker) {
         throw "Wasm module must be loaded first";
     return createProxy(worker, wasmModule, compilerProtocol);
 }
-export async function getLanguageService(readFile, listDir, getManifest) {
+export async function getLanguageService(host) {
     await instantiateWasm();
-    return new QSharpLanguageService(wasm, readFile, listDir, getManifest);
+    return new QSharpLanguageService(wasm, host);
 }
 // Create the compiler inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
@@ -109,7 +109,6 @@ export function getLanguageServiceWorker(worker) {
 }
 export { StepResultId } from "../lib/web/qsc_wasm.js";
 export { QscEventTarget } from "./compiler/events.js";
-export { getAllKatas, getExerciseSources, getKata, } from "./katas.js";
 export { default as samples } from "./samples.generated.js";
 export { log };
 export * as utils from "./utils.js";

package/dist/compiler/compiler.d.ts

@@ -1,5 +1,5 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
-import { IDocFile, IOperationInfo, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
+import { IDocFile, IOperationInfo, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
 import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
@@ -7,35 +7,17 @@ export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    run(config: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    getQir(sources: [string, string][], languageFeatures?: string[]): Promise<string>;
-    getQir(config: ProgramConfig): Promise<string>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    getEstimates(sources: [string, string][], params: string, languageFeatures?: string[]): Promise<string>;
-    getEstimates(config: ProgramConfig, params: string): Promise<string>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
-/** Type definition for the configuration of a program. */
+/**
+ * Type definition for the configuration of a program.
+ * If adding new properties, make them optional to maintain backward compatibility.
+ */
 export type ProgramConfig = {
     /** An array of source objects, each containing a name and contents. */
     sources: [string, string][];
@@ -50,19 +32,20 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(sourcesOrConfig: [string, string][] | ProgramConfig, languageFeatures?: string[]): Promise<string>;
-    newGetQir({ sources, languageFeatures, profile, }: ProgramConfig): Promise<string>;
-    deprecatedGetQir(sources: [string, string][], languageFeatures: string[]): Promise<string>;
-    getEstimates(sourcesOrConfig: [string, string][] | ProgramConfig, params: string, languageFeatures?: string[]): Promise<string>;
-    newGetEstimates({ sources, languageFeatures, profile }: ProgramConfig, params: string): Promise<string>;
-    deprecatedGetEstimates(sources: [string, string][], params: string, languageFeatures: string[]): Promise<string>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
-    run(sourcesOrConfig: [string, string][] | ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export declare function toWasmProgramConfig(program: ProgramConfig, defaultProfile: TargetProfile): Required<wasmIProgramConfig>;
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
 /** The protocol definition to allow running the compiler in a worker. */
 export declare const compilerProtocol: ServiceProtocol<ICompiler, QscEventData>;

package/dist/compiler/compiler.js

@@ -16,7 +16,12 @@ export class Compiler {
         const languageService = new this.wasm.LanguageService();
         const work = languageService.start_background_work((uri, version, errors) => {
             diags = errors;
-        }, () => Promise.resolve(null), () => Promise.resolve([]), () => Promise.resolve(null));
+        }, {
+            readFile: async () => null,
+            listDirectory: async () => [],
+            resolvePath: async () => null,
+            findManifestDirectory: async () => null,
+        });
         languageService.update_document("code", 1, code);
         // Yield to let the language service background worker handle the update
         await Promise.resolve();
@@ -25,75 +30,50 @@ export class Compiler {
         languageService.free();
         return diags;
     }
-    async getQir(sourcesOrConfig, languageFeatures) {
-        if (Array.isArray(sourcesOrConfig)) {
-            return this.deprecatedGetQir(sourcesOrConfig, languageFeatures || []);
-        }
-        else {
-            const config = sourcesOrConfig;
-            return this.newGetQir(config);
-        }
-    }
-    async newGetQir({ sources, languageFeatures = [], profile = "base", }) {
-        return this.wasm.get_qir(sources, languageFeatures, profile);
-    }
-    async deprecatedGetQir(sources, languageFeatures) {
-        return this.wasm.get_qir(sources, languageFeatures, "base");
-    }
-    async getEstimates(sourcesOrConfig, params, languageFeatures = []) {
-        if (Array.isArray(sourcesOrConfig)) {
-            return this.deprecatedGetEstimates(sourcesOrConfig, params, languageFeatures);
-        }
-        else {
-            return this.newGetEstimates(sourcesOrConfig, params);
-        }
-    }
-    async newGetEstimates({ sources, languageFeatures, profile = "unrestricted" }, params) {
-        return this.wasm.get_estimates(sources, params, languageFeatures || [], profile);
-    }
-    async deprecatedGetEstimates(sources, params, languageFeatures) {
-        return this.wasm.get_estimates(sources, params, languageFeatures, "unrestricted");
-    }
     async getAst(code, languageFeatures, profile) {
         return this.wasm.get_ast(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
     async getHir(code, languageFeatures, profile) {
         return this.wasm.get_hir(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
-    async run(sourcesOrConfig, expr, shots, eventHandler) {
-        let sources;
-        let profile = "unrestricted";
-        let languageFeatures = [];
-        if (Array.isArray(sourcesOrConfig)) {
-            // this is the deprecated API
-            sources = sourcesOrConfig;
-        }
-        else {
-            // this is the new API
-            sources = sourcesOrConfig.sources;
-            languageFeatures = sourcesOrConfig.languageFeatures || [];
-            profile = sourcesOrConfig.profile || "unrestricted";
-        }
+    async run(program, expr, shots, eventHandler) {
         // All results are communicated as events, but if there is a compiler error (e.g. an invalid
         // entry expression or similar), it may throw on run. The caller should expect this promise
         // may reject without all shots running or events firing.
-        this.wasm.run(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots, languageFeatures, profile);
+        this.wasm.run(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+    }
+    async getQir(program) {
+        return this.wasm.get_qir(toWasmProgramConfig(program, "base"));
     }
-    async getCircuit(config, target, simulate, operation) {
-        return this.wasm.get_circuit(config.sources, target, config.languageFeatures || [], simulate, operation);
+    async getEstimates(program, params) {
+        return this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), params);
+    }
+    async getCircuit(program, simulate, operation) {
+        return this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
     }
     // Returns all autogenerated documentation files for the standard library
     // and loaded project (if requested). This include file names and metadata,
     // including specially formatted table of content file.
-    async getDocumentation(additionalSources, targetProfile, languageFeatures) {
-        // Get documentation from wasm layer
-        return this.wasm.generate_docs(additionalSources, targetProfile, languageFeatures);
+    async getDocumentation(additionalProgram) {
+        return this.wasm.generate_docs(additionalProgram &&
+            toWasmProgramConfig(additionalProgram, "unrestricted"));
     }
     async checkExerciseSolution(userCode, exerciseSources, eventHandler) {
         const success = this.wasm.check_exercise_solution(userCode, exerciseSources, (msg) => onCompilerEvent(msg, eventHandler));
         return success;
     }
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export function toWasmProgramConfig(program, defaultProfile) {
+    return {
+        sources: program.sources,
+        languageFeatures: program.languageFeatures || [],
+        profile: program.profile || defaultProfile,
+    };
+}
 export function onCompilerEvent(msg, eventTarget) {
     const qscMsg = eventStringToMsg(msg);
     if (!qscMsg) {

package/dist/debug-service/debug-service.d.ts

@@ -1,11 +1,11 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
 import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../browser.js";
+import { ProgramConfig } from "../browser.js";
 import { IQscEventTarget, QscEventData } from "../compiler/events.js";
 import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface IDebugService {
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;
@@ -22,7 +22,7 @@ export declare class QSharpDebugService implements IDebugService {
     private wasm;
     private debugService;
     constructor(wasm: QscWasm);
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;

package/dist/debug-service/debug-service.js

@@ -3,14 +3,15 @@
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
+import { toWasmProgramConfig } from "../compiler/compiler.js";
 export class QSharpDebugService {
     constructor(wasm) {
         log.info("Constructing a QSharpDebugService instance");
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(sources, target, entry, language_features) {
-        return this.debugService.load_source(sources, target, entry, language_features);
+    async loadProgram(program, entry) {
+        return this.debugService.load_program(toWasmProgramConfig(program, "unrestricted"), entry);
     }
     async getBreakpoints(path) {
         return this.debugService.get_breakpoints(path).spans;
@@ -85,7 +86,7 @@ export function onCompilerEvent(msg, eventTarget) {
 export const debugServiceProtocol = {
     class: QSharpDebugService,
     methods: {
-        loadSource: "request",
+        loadProgram: "request",
         getBreakpoints: "request",
         getLocalVariables: "request",
         captureQuantumState: "request",

package/dist/katas-content.generated.d.ts

@@ -8,16 +8,14 @@ declare const _default: {
             title: string;
             items: ({
                 type: string;
-                asHtml: string;
-                asMarkdown: string;
+                content: string;
                 id?: undefined;
                 code?: undefined;
             } | {
                 type: string;
                 id: string;
                 code: string;
-                asHtml?: undefined;
-                asMarkdown?: undefined;
+                content?: undefined;
             })[];
             description?: undefined;
             sourceIds?: undefined;
@@ -29,8 +27,7 @@ declare const _default: {
             title: string;
             description: {
                 type: string;
-                asHtml: string;
-                asMarkdown: string;
+                content: string;
             };
             sourceIds: string[];
             placeholderCode: string;
@@ -38,16 +35,14 @@ declare const _default: {
                 type: string;
                 items: ({
                     type: string;
-                    asHtml: string;
-                    asMarkdown: string;
+                    content: string;
                     id?: undefined;
                     code?: undefined;
                 } | {
                     type: string;
                     id: string;
                     code: string;
-                    asHtml?: undefined;
-                    asMarkdown?: undefined;
+                    content?: undefined;
                 })[];
             };
             items?: undefined;