@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.7

package/dist/debugger/replay/replay-update-loader.js

@@ -0,0 +1,94 @@
+import { GetUpdateByOffsetRequest } from "../../core/types/requests/get-update-by-offset-request.js";
+import { ReplayUnsupportedUpdateException } from "../errors/replay-unsupported-update.exception.js";
+import { ReplayEntrypoint } from "./replay-entrypoint.js";
+import { validateReplayVisibilityOrThrow } from "./replay-update-visibility-validator.js";
+import { TransactionShape } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/transaction_filter.js";
+export class ReplayUpdateLoader {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async loadOrThrowAsync(offset) {
+        const response = await this.dependencies.updateService.getUpdateByOffsetAsync(new GetUpdateByOffsetRequest({
+            offset,
+            updateFormat: createReplayUpdateFormat(this.dependencies.visibleParties),
+        }));
+        const transaction = response.update;
+        if (transaction === undefined ||
+            !Array.isArray(transaction.events) ||
+            transaction.offset === undefined) {
+            throw new ReplayUnsupportedUpdateException("update is not a replayable transaction payload");
+        }
+        validateReplayVisibilityOrThrow(transaction);
+        return {
+            kind: "transaction",
+            offset: transaction.offset,
+            updateId: transaction.updateId,
+            actAs: transaction.actAs,
+            readAs: transaction.readAs,
+            events: transaction.events,
+            entrypoint: this.deriveEntrypointOrThrow(transaction.events),
+        };
+    }
+    deriveEntrypointOrThrow(events) {
+        const firstEvent = events[0]?.event;
+        if (firstEvent?.oneofKind === "created" &&
+            firstEvent.created?.templateId !== undefined &&
+            firstEvent.created.createArguments !== undefined) {
+            return new ReplayEntrypoint({
+                kind: "create",
+                templateId: firstEvent.created.templateId,
+                argument: firstEvent.created.createArguments,
+            });
+        }
+        if (firstEvent?.oneofKind === "exercised" &&
+            firstEvent.exercised?.templateId !== undefined &&
+            firstEvent.exercised.contractId !== undefined &&
+            firstEvent.exercised.choice !== undefined &&
+            firstEvent.exercised.choiceArgument !== undefined) {
+            return new ReplayEntrypoint({
+                kind: "exercise",
+                templateId: firstEvent.exercised.templateId,
+                contractId: firstEvent.exercised.contractId,
+                choice: firstEvent.exercised.choice,
+                argument: firstEvent.exercised.choiceArgument,
+            });
+        }
+        throw new ReplayUnsupportedUpdateException("could not derive a replay entrypoint from the visible update payload");
+    }
+}
+function createReplayUpdateFormat(visibleParties) {
+    return {
+        includeTransactions: {
+            eventFormat: createReplayEventFormat(visibleParties),
+            transactionShape: TransactionShape.LEDGER_EFFECTS,
+        },
+    };
+}
+function createReplayEventFormat(visibleParties) {
+    const wildcardFilter = {
+        cumulative: [
+            {
+                identifierFilter: {
+                    oneofKind: "wildcardFilter",
+                    wildcardFilter: {
+                        includeCreatedEventBlob: true,
+                    },
+                },
+            },
+        ],
+    };
+    if (Array.isArray(visibleParties) && visibleParties.length > 0) {
+        return {
+            filtersByParty: Object.fromEntries([...new Set(visibleParties)]
+                .filter((party) => typeof party === "string" && party.length > 0)
+                .map((party) => [party, wildcardFilter])),
+            verbose: true,
+        };
+    }
+    return {
+        filtersByParty: {},
+        filtersForAnyParty: wildcardFilter,
+        verbose: true,
+    };
+}

package/dist/debugger/replay/replay-update-visibility-validator.d.ts

@@ -0,0 +1,19 @@
+type ReplayLikeEvent = {
+    event?: {
+        oneofKind?: string;
+        created?: {
+            templateId?: unknown;
+            createArguments?: unknown;
+        };
+        exercised?: {
+            templateId?: unknown;
+            contractId?: string;
+            choice?: string;
+            choiceArgument?: unknown;
+        };
+    };
+};
+export declare function validateReplayVisibilityOrThrow(update: {
+    events?: ReplayLikeEvent[];
+}): void;
+export {};

package/dist/debugger/replay/replay-update-visibility-validator.js

@@ -0,0 +1,19 @@
+import { ReplayUnsupportedUpdateException } from "../errors/replay-unsupported-update.exception.js";
+export function validateReplayVisibilityOrThrow(update) {
+    for (const event of update.events ?? []) {
+        if (event.event?.oneofKind === "created") {
+            if (event.event.created?.templateId === undefined ||
+                event.event.created.createArguments === undefined) {
+                throw new ReplayUnsupportedUpdateException("created events must include template id and create arguments for replay");
+            }
+        }
+        if (event.event?.oneofKind === "exercised") {
+            if (event.event.exercised?.templateId === undefined ||
+                event.event.exercised.contractId === undefined ||
+                event.event.exercised.choice === undefined ||
+                event.event.exercised.choiceArgument === undefined) {
+                throw new ReplayUnsupportedUpdateException("exercised events must include template id, contract id, choice, and choice argument for replay");
+            }
+        }
+    }
+}

package/dist/debugger/session/in-memory-replay-session-store.d.ts

@@ -0,0 +1,27 @@
+import { ILoadedReplaySession } from "../replay/ledger-replay-session-loader.js";
+import { ReplayScope } from "./replay-scope.js";
+import { ReplaySession } from "./replay-session.js";
+import { ReplaySessionMetadata } from "./replay-session-metadata.js";
+import { ReplayStackFrame } from "./replay-stack-frame.js";
+import { ReplayStep } from "./replay-step.js";
+import { ReplayStepAdvanceResult } from "./replay-step-advance-result.js";
+export declare class InMemoryReplaySessionStore {
+    private readonly sessions;
+    put(session: ILoadedReplaySession): ReplaySession;
+    getSessionMetadataOrThrow(sessionId: string): ReplaySessionMetadata;
+    getCurrentStepOrThrow(sessionId: string): ReplayStep;
+    advanceIntoOrThrow(sessionId: string): ReplayStepAdvanceResult;
+    advanceBackOrThrow(sessionId: string): ReplayStepAdvanceResult;
+    advanceOverOrThrow(sessionId: string): ReplayStepAdvanceResult;
+    advanceOutOrThrow(sessionId: string): ReplayStepAdvanceResult;
+    continueOrThrow(sessionId: string): ReplayStepAdvanceResult;
+    setCurrentStepByIdOrThrow(sessionId: string, stepId: string): ReplayStepAdvanceResult;
+    getStackOrThrow(sessionId: string): readonly ReplayStackFrame[];
+    getScopesOrThrow(sessionId: string, frameId: string): readonly ReplayScope[];
+    getTraceSliceOrThrow(sessionId: string, startIndex: number, endIndex: number): readonly ReplayStep[];
+    dispose(sessionId: string): void;
+    private getRecordOrThrow;
+    private toReplaySession;
+    private toAdvanceResult;
+    private findNextIndexOrCurrent;
+}

package/dist/debugger/session/in-memory-replay-session-store.js

@@ -0,0 +1,109 @@
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { ReplaySession } from "./replay-session.js";
+import { ReplayStepAdvanceResult } from "./replay-step-advance-result.js";
+export class InMemoryReplaySessionStore {
+    sessions = new Map();
+    put(session) {
+        this.sessions.set(session.sessionId, {
+            ...session,
+            currentStepIndex: session.currentStepIndex,
+        });
+        return this.toReplaySession(this.getRecordOrThrow(session.sessionId));
+    }
+    getSessionMetadataOrThrow(sessionId) {
+        return this.getRecordOrThrow(sessionId).metadata;
+    }
+    getCurrentStepOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        return record.steps[record.currentStepIndex];
+    }
+    advanceIntoOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const nextIndex = Math.min(record.currentStepIndex + 1, record.steps.length - 1);
+        record.currentStepIndex = nextIndex;
+        return this.toAdvanceResult(record);
+    }
+    advanceBackOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        record.currentStepIndex = Math.max(0, record.currentStepIndex - 1);
+        return this.toAdvanceResult(record);
+    }
+    advanceOverOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const currentStep = record.steps[record.currentStepIndex];
+        if (currentStep.phase !== "call") {
+            return this.advanceIntoOrThrow(sessionId);
+        }
+        record.currentStepIndex = this.findNextIndexOrCurrent(record, (step) => step.stackFrames.length < currentStep.stackFrames.length);
+        return this.toAdvanceResult(record);
+    }
+    advanceOutOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const currentStep = record.steps[record.currentStepIndex];
+        record.currentStepIndex = this.findNextIndexOrCurrent(record, (step) => step.stackFrames.length < currentStep.stackFrames.length);
+        return this.toAdvanceResult(record);
+    }
+    continueOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        record.currentStepIndex = record.steps.length - 1;
+        return this.toAdvanceResult(record);
+    }
+    setCurrentStepByIdOrThrow(sessionId, stepId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const nextIndex = record.steps.findIndex((step) => step.stepId === stepId);
+        if (nextIndex < 0) {
+            throw new ValidationError(`unknown replay step '${stepId}'`);
+        }
+        record.currentStepIndex = nextIndex;
+        return this.toAdvanceResult(record);
+    }
+    getStackOrThrow(sessionId) {
+        return this.getCurrentStepOrThrow(sessionId).stackFrames;
+    }
+    getScopesOrThrow(sessionId, frameId) {
+        const currentStep = this.getCurrentStepOrThrow(sessionId);
+        const frame = currentStep.stackFrames.find((candidate) => candidate.frameId === frameId);
+        if (frame === undefined) {
+            return [];
+        }
+        return (this.getRecordOrThrow(sessionId).scopesByStep[this.getRecordOrThrow(sessionId).currentStepIndex] ?? []).filter((scope) => scope.frameId === frameId);
+    }
+    getTraceSliceOrThrow(sessionId, startIndex, endIndex) {
+        return this.getRecordOrThrow(sessionId).steps.slice(startIndex, endIndex);
+    }
+    dispose(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    getRecordOrThrow(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session === undefined) {
+            throw new ValidationError(`replay session '${sessionId}' does not exist`);
+        }
+        return session;
+    }
+    toReplaySession(session) {
+        return new ReplaySession({
+            sessionId: session.sessionId,
+            metadata: session.metadata,
+            currentStep: session.steps[session.currentStepIndex],
+        });
+    }
+    toAdvanceResult(session) {
+        return new ReplayStepAdvanceResult({
+            sessionId: session.sessionId,
+            step: session.steps[session.currentStepIndex],
+            isTerminal: session.currentStepIndex >= session.steps.length - 1,
+            nextStepIndex: session.currentStepIndex >= session.steps.length - 1
+                ? undefined
+                : session.currentStepIndex + 1,
+        });
+    }
+    findNextIndexOrCurrent(session, predicate) {
+        for (let index = session.currentStepIndex + 1; index < session.steps.length; index += 1) {
+            if (predicate(session.steps[index])) {
+                return index;
+            }
+        }
+        return session.steps.length - 1;
+    }
+}

package/dist/debugger/session/replay-phase.d.ts

@@ -0,0 +1,7 @@
+export declare enum ReplayPhase {
+    enterExpression = "enterExpression",
+    exitExpression = "exitExpression",
+    call = "call",
+    return = "return",
+    stateEffect = "stateEffect"
+}

package/dist/debugger/session/replay-phase.js

@@ -0,0 +1,8 @@
+export var ReplayPhase;
+(function (ReplayPhase) {
+    ReplayPhase["enterExpression"] = "enterExpression";
+    ReplayPhase["exitExpression"] = "exitExpression";
+    ReplayPhase["call"] = "call";
+    ReplayPhase["return"] = "return";
+    ReplayPhase["stateEffect"] = "stateEffect";
+})(ReplayPhase || (ReplayPhase = {}));

package/dist/debugger/session/replay-scope.d.ts

@@ -0,0 +1,10 @@
+export declare class ReplayScope {
+    readonly frameId?: string;
+    readonly name?: string;
+    readonly variables: readonly unknown[];
+    constructor(init?: {
+        frameId?: string;
+        name?: string;
+        variables?: readonly unknown[];
+    });
+}

package/dist/debugger/session/replay-scope.js

@@ -0,0 +1,10 @@
+export class ReplayScope {
+    frameId;
+    name;
+    variables;
+    constructor(init) {
+        this.frameId = init?.frameId;
+        this.name = init?.name;
+        this.variables = init?.variables ?? [];
+    }
+}

package/dist/debugger/session/replay-session-metadata.d.ts

@@ -0,0 +1,10 @@
+export declare class ReplaySessionMetadata {
+    readonly sessionId?: string;
+    readonly offset?: string;
+    readonly stepCount?: number;
+    constructor(init?: {
+        sessionId?: string;
+        offset?: string;
+        stepCount?: number;
+    });
+}

package/dist/debugger/session/replay-session-metadata.js

@@ -0,0 +1,10 @@
+export class ReplaySessionMetadata {
+    sessionId;
+    offset;
+    stepCount;
+    constructor(init) {
+        this.sessionId = init?.sessionId;
+        this.offset = init?.offset;
+        this.stepCount = init?.stepCount;
+    }
+}

package/dist/debugger/session/replay-session-request.d.ts

@@ -0,0 +1,6 @@
+export declare class ReplaySessionRequest {
+    readonly offset: string;
+    constructor(init: {
+        offset: string;
+    });
+}

package/dist/debugger/session/replay-session-request.js

@@ -0,0 +1,10 @@
+import { ValidationError } from "../../core/errors/validation-error.js";
+export class ReplaySessionRequest {
+    offset;
+    constructor(init) {
+        if (!init.offset) {
+            throw new ValidationError("replay session requests require an offset");
+        }
+        this.offset = init.offset;
+    }
+}

package/dist/debugger/session/replay-session.d.ts

@@ -0,0 +1,12 @@
+import { ReplaySessionMetadata } from "./replay-session-metadata.js";
+import { ReplayStep } from "./replay-step.js";
+export declare class ReplaySession {
+    readonly sessionId?: string;
+    readonly metadata?: ReplaySessionMetadata;
+    readonly currentStep?: ReplayStep;
+    constructor(init?: {
+        sessionId?: string;
+        metadata?: ReplaySessionMetadata;
+        currentStep?: ReplayStep;
+    });
+}

package/dist/debugger/session/replay-session.js

@@ -0,0 +1,10 @@
+export class ReplaySession {
+    sessionId;
+    metadata;
+    currentStep;
+    constructor(init) {
+        this.sessionId = init?.sessionId;
+        this.metadata = init?.metadata;
+        this.currentStep = init?.currentStep;
+    }
+}

package/dist/debugger/session/replay-source-location.d.ts

@@ -0,0 +1,17 @@
+import { SourceMappingPrecision } from "../source/source-mapping-precision.js";
+export declare class ReplaySourceLocation {
+    readonly path?: string;
+    readonly startLine?: number;
+    readonly startColumn?: number;
+    readonly endLine?: number;
+    readonly endColumn?: number;
+    readonly precision: SourceMappingPrecision;
+    constructor(init: {
+        path?: string;
+        startLine?: number;
+        startColumn?: number;
+        endLine?: number;
+        endColumn?: number;
+        precision: SourceMappingPrecision;
+    });
+}

package/dist/debugger/session/replay-source-location.js

@@ -0,0 +1,16 @@
+export class ReplaySourceLocation {
+    path;
+    startLine;
+    startColumn;
+    endLine;
+    endColumn;
+    precision;
+    constructor(init) {
+        this.path = init?.path;
+        this.startLine = init?.startLine;
+        this.startColumn = init?.startColumn;
+        this.endLine = init?.endLine;
+        this.endColumn = init?.endColumn;
+        this.precision = init.precision;
+    }
+}

package/dist/debugger/session/replay-stack-frame.d.ts

@@ -0,0 +1,8 @@
+export declare class ReplayStackFrame {
+    readonly frameId?: string;
+    readonly name?: string;
+    constructor(init?: {
+        frameId?: string;
+        name?: string;
+    });
+}

package/dist/debugger/session/replay-stack-frame.js

@@ -0,0 +1,8 @@
+export class ReplayStackFrame {
+    frameId;
+    name;
+    constructor(init) {
+        this.frameId = init?.frameId;
+        this.name = init?.name;
+    }
+}

package/dist/debugger/session/replay-state-delta.d.ts

@@ -0,0 +1,29 @@
+export interface IReplayStateDeltaTemplateId {
+    readonly packageId?: string;
+    readonly moduleName?: string;
+    readonly entityName?: string;
+}
+export declare class ReplayStateDelta {
+    readonly kind: string;
+    readonly eventOrdinal?: number;
+    readonly comparisonKey?: string;
+    readonly createdContractId?: string;
+    readonly targetContractId?: string;
+    readonly templateId?: IReplayStateDeltaTemplateId;
+    readonly choice?: string;
+    readonly choiceArgument?: unknown;
+    readonly payload?: unknown;
+    readonly consuming?: boolean;
+    constructor(init: {
+        kind: string;
+        eventOrdinal?: number;
+        comparisonKey?: string;
+        createdContractId?: string;
+        targetContractId?: string;
+        templateId?: IReplayStateDeltaTemplateId;
+        choice?: string;
+        choiceArgument?: unknown;
+        payload?: unknown;
+        consuming?: boolean;
+    });
+}

package/dist/debugger/session/replay-state-delta.js

@@ -0,0 +1,24 @@
+export class ReplayStateDelta {
+    kind;
+    eventOrdinal;
+    comparisonKey;
+    createdContractId;
+    targetContractId;
+    templateId;
+    choice;
+    choiceArgument;
+    payload;
+    consuming;
+    constructor(init) {
+        this.kind = init.kind;
+        this.eventOrdinal = init.eventOrdinal;
+        this.comparisonKey = init.comparisonKey;
+        this.createdContractId = init.createdContractId;
+        this.targetContractId = init.targetContractId;
+        this.templateId = init.templateId;
+        this.choice = init.choice;
+        this.choiceArgument = init.choiceArgument;
+        this.payload = init.payload;
+        this.consuming = init.consuming;
+    }
+}

package/dist/debugger/session/replay-step-advance-result.d.ts

@@ -0,0 +1,24 @@
+import { ReplayStep } from "./replay-step.js";
+export declare class ReplayStepAdvanceResult {
+    readonly sessionId: string;
+    readonly step: ReplayStep;
+    readonly isTerminal: boolean;
+    readonly nextStepIndex?: number;
+    constructor(init: {
+        sessionId: string;
+        step: {
+            stepId?: string;
+            stepIndex: number;
+            phase: ReplayStep["phase"];
+            stackFrames?: ReplayStep["stackFrames"];
+            scopes?: ReplayStep["scopes"];
+            locals?: ReplayStep["locals"];
+            arguments?: ReplayStep["arguments"];
+            sourceLocation?: ReplayStep["sourceLocation"];
+            valuePreview?: ReplayStep["valuePreview"];
+            stateDelta?: ReplayStep["stateDelta"];
+        } | ReplayStep;
+        isTerminal: boolean;
+        nextStepIndex?: number;
+    });
+}

package/dist/debugger/session/replay-step-advance-result.js

@@ -0,0 +1,16 @@
+import { ReplayStep } from "./replay-step.js";
+export class ReplayStepAdvanceResult {
+    sessionId;
+    step;
+    isTerminal;
+    nextStepIndex;
+    constructor(init) {
+        this.sessionId = init.sessionId;
+        this.step =
+            init.step instanceof ReplayStep
+                ? init.step
+                : new ReplayStep(init.step);
+        this.isTerminal = init.isTerminal;
+        this.nextStepIndex = init.nextStepIndex;
+    }
+}

package/dist/debugger/session/replay-step.d.ts

@@ -0,0 +1,30 @@
+import { ReplayPhase } from "./replay-phase.js";
+import { ReplayScope } from "./replay-scope.js";
+import { ReplaySourceLocation } from "./replay-source-location.js";
+import { ReplayStackFrame } from "./replay-stack-frame.js";
+import { ReplayStateDelta } from "./replay-state-delta.js";
+import { ReplayValuePreview } from "./replay-value-preview.js";
+export declare class ReplayStep {
+    readonly stepId: string;
+    readonly stepIndex: number;
+    readonly phase: ReplayPhase;
+    readonly stackFrames: readonly ReplayStackFrame[];
+    readonly scopes: readonly ReplayScope[];
+    readonly locals: readonly unknown[];
+    readonly arguments: readonly unknown[];
+    readonly sourceLocation?: ReplaySourceLocation;
+    readonly valuePreview?: ReplayValuePreview;
+    readonly stateDelta?: ReplayStateDelta;
+    constructor(init: {
+        stepId?: string;
+        stepIndex: number;
+        phase: ReplayPhase;
+        stackFrames?: readonly ReplayStackFrame[];
+        scopes?: readonly ReplayScope[];
+        locals?: readonly unknown[];
+        arguments?: readonly unknown[];
+        sourceLocation?: ReplaySourceLocation;
+        valuePreview?: ReplayValuePreview;
+        stateDelta?: ReplayStateDelta;
+    });
+}

package/dist/debugger/session/replay-step.js

@@ -0,0 +1,24 @@
+export class ReplayStep {
+    stepId;
+    stepIndex;
+    phase;
+    stackFrames;
+    scopes;
+    locals;
+    arguments;
+    sourceLocation;
+    valuePreview;
+    stateDelta;
+    constructor(init) {
+        this.stepId = init.stepId ?? `step-${init.stepIndex}`;
+        this.stepIndex = init.stepIndex;
+        this.phase = init.phase;
+        this.stackFrames = init.stackFrames ?? [];
+        this.scopes = init.scopes ?? [];
+        this.locals = init.locals ?? [];
+        this.arguments = init.arguments ?? [];
+        this.sourceLocation = init.sourceLocation;
+        this.valuePreview = init.valuePreview;
+        this.stateDelta = init.stateDelta;
+    }
+}

package/dist/debugger/session/replay-value-preview.d.ts

@@ -0,0 +1,8 @@
+export declare class ReplayValuePreview {
+    readonly kind: string;
+    readonly display: string;
+    constructor(init: {
+        kind: string;
+        display: string;
+    });
+}

package/dist/debugger/session/replay-value-preview.js

@@ -0,0 +1,15 @@
+import { ValidationError } from "../../core/errors/validation-error.js";
+export class ReplayValuePreview {
+    kind;
+    display;
+    constructor(init) {
+        if (!init.kind) {
+            throw new ValidationError("replay value previews require a kind");
+        }
+        if (!init.display) {
+            throw new ValidationError("replay value previews require a display value");
+        }
+        this.kind = init.kind;
+        this.display = init.display;
+    }
+}

package/dist/debugger/source/daml-source-mapper.d.ts

@@ -0,0 +1,12 @@
+import { SourceIndexedCompilation } from "./source-indexed-compilation.js";
+import { DamlLfExpression } from "../../daml-lf/model/daml-lf-expression.js";
+import { DamlLfValueDefinition } from "../../daml-lf/model/daml-lf-value-definition.js";
+export declare class DamlSourceMapper {
+    private readonly indexedCompilation;
+    constructor(indexedCompilation: SourceIndexedCompilation);
+    getDefinitionSourceOrThrow(packageId: string, moduleName: string, definitionName: string): import("./source-indexed-compilation.js").IndexedExecutableSource;
+    getModuleSourceOrThrow(packageId: string, moduleName: string): import("./source-indexed-compilation.js").IndexedDefinitionSource;
+    getExpressionSource(expression: DamlLfExpression): import("./source-indexed-compilation.js").IndexedExpressionSource | undefined;
+    getValueDefinitionOrThrow(packageId: string, moduleName: string, definitionName: string): DamlLfValueDefinition;
+    findExecutableSourceAt(path: string, line: number, column: number): import("./source-indexed-compilation.js").IndexedExecutableSource | undefined;
+}

package/dist/debugger/source/daml-source-mapper.js

@@ -0,0 +1,21 @@
+export class DamlSourceMapper {
+    indexedCompilation;
+    constructor(indexedCompilation) {
+        this.indexedCompilation = indexedCompilation;
+    }
+    getDefinitionSourceOrThrow(packageId, moduleName, definitionName) {
+        return this.indexedCompilation.getDefinitionSourceOrThrow(packageId, moduleName, definitionName);
+    }
+    getModuleSourceOrThrow(packageId, moduleName) {
+        return this.indexedCompilation.getModuleSourceOrThrow(packageId, moduleName);
+    }
+    getExpressionSource(expression) {
+        return this.indexedCompilation.getExpressionSource(expression);
+    }
+    getValueDefinitionOrThrow(packageId, moduleName, definitionName) {
+        return this.indexedCompilation.compilation.getValueDefinitionOrThrow(packageId, moduleName, definitionName);
+    }
+    findExecutableSourceAt(path, line, column) {
+        return this.indexedCompilation.findExecutableSourceAt(path, line, column);
+    }
+}