@hydranium/glsp-server 1.0.0-next.10

package/lib/state/reconciling-multi-document-glsp-state.js

@@ -0,0 +1,222 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+import { reconcileSourceModelWrite } from './reconcile-source-model-write.js';
+/**
+ * Editable GLSP state for a diagram whose edits span SEVERAL Langium documents —
+ * a diagram file plus the semantic file it references, say, where creating a node
+ * on the canvas writes both.
+ *
+ * The single-document `ReconcilingTransferHydraniumGlspState` cannot express
+ * that: its `sourceModel`, `persist` and `refetch` are all defined over
+ * `sourceUri` alone, so an adopter needing a second document had to override all
+ * three — i.e. the entire class. This subclass keeps the same three seams and the
+ * same conflict handling (both share {@link reconcileSourceModelWrite}) but
+ * defines them over the primary plus the secondary write set registered through
+ * {@link AbstractHydraniumGlspState.trackSecondaryDocument}.
+ *
+ * **Writes are NOT atomic, deliberately, and the window is real.** Each document
+ * goes through its own `ModelService.update`, so a failure after the first write
+ * has landed leaves the set inconsistent on disk. There is no multi-document
+ * transaction to lean on: `WorkspaceLock` serialises builds but does not roll
+ * back, and the document store commits per URI. An adopter that cannot accept the
+ * window should not span documents in one operation.
+ *
+ * **What makes the window tolerable is write ORDER, and the rule is
+ * referenced-before-referencing** — not "secondaries first" as such. Write the
+ * document whose content the others point AT before the documents that point at
+ * it, so a partial write leaves an unreferenced element (inert, and the direction
+ * an integrity rule can repair) rather than a reference to something that does
+ * not exist (a linking error). {@link persist} implements that as
+ * secondaries-then-primary, which is correct for the common shape where the
+ * primary is the DIAGRAM and the semantics it references are secondaries: the
+ * user opened the diagram, so it is also the document the conflict gate should
+ * guard. **An adopter whose primary is the referenced document — a semantic file
+ * as the diagram source, with layout in a secondary — has the ordering backwards
+ * and must override {@link persist} to write the primary first.** Overriding it
+ * is the supported route; the base order is a default for the common case, not an
+ * invariant of the class.
+ *
+ * **The conflict gate covers the primary only.** Secondaries are written without
+ * a based-on version, so a concurrent foreign edit to one is overwritten rather
+ * than reconciled. Gating them too would need a per-document reconcile whose
+ * outcomes can disagree (merge one, conflict another) with no way to un-write the
+ * merged one — the atomicity problem again, one layer up. The captured versions
+ * ARE available via {@link AbstractHydraniumGlspState.capturedVersionOf}, so an
+ * adopter that wants a coarser check can compare before writing.
+ */
+let ReconcilingMultiDocumentGlspState = class ReconcilingMultiDocumentGlspState extends AbstractHydraniumGlspState {
+    /**
+     * Last in-sync projection across the whole write set, captured on every
+     * {@link setSourceRoot}. Same role as the single-document baseline: the state a
+     * forward-write conflict reconciles the user's intent against.
+     */
+    baseline;
+    /**
+     * Projection of the primary plus every registered secondary, in the framework
+     * encoder's `'grammar'` mode (authored state only — cross-references as
+     * `$refText`, computed / synthetic properties excluded), so `fast-json-patch`
+     * diffs per field across all of them at once.
+     *
+     * A secondary that is not currently loaded is OMITTED rather than represented
+     * as `undefined`: an absent key produces no patch operations for that
+     * document, whereas an explicit `undefined` would diff as a removal and
+     * persist as a deletion of content the state simply could not see.
+     */
+    get sourceModel() {
+        const secondaries = {};
+        for (const uri of this.secondaryUris) {
+            const projection = this.projectDocument(uri);
+            if (projection) {
+                secondaries[uri] = projection;
+            }
+        }
+        return { primary: this.projectRoot(this._sourceRoot), secondaries };
+    }
+    setSourceRoot(uri, root) {
+        super.setSourceRoot(uri, root);
+        this.trackWriteSet(uri);
+        this.baseline = this.sourceModel;
+    }
+    /**
+     * Register the secondary documents that belong to the primary at `uri`, via
+     * {@link AbstractHydraniumGlspState.trackSecondaryDocument}. Called on every
+     * {@link setSourceRoot}, after the primary is captured (so `sourceUri` is
+     * current) and BEFORE the baseline is taken (so the baseline includes them).
+     * Default: no secondaries.
+     *
+     * This hook exists because that ordering is a trap an adopter would otherwise
+     * hit silently. Registering from an overridden `setSourceRoot` *after*
+     * `super.setSourceRoot(...)` runs too late — the baseline has already been
+     * captured without the secondaries, so the first conflict reconcile measures
+     * the user's intent against a baseline missing half the write set and the
+     * secondary edits look like foreign changes. Registering *before* the super
+     * call is too early for a URI derived from the new primary. Overriding this
+     * instead removes the choice.
+     */
+    trackWriteSet(_uri) {
+        // No-op by default; adopters with secondaries override.
+    }
+    /**
+     * Persist the whole write set, then capture the resulting primary root. On a
+     * `ConflictError` from the primary, reconcile via the injected policy exactly
+     * as the single-document state does — the orchestration is shared.
+     */
+    async updateSourceModel(model, version) {
+        return reconcileSourceModelWrite(model, version, {
+            persist: async (candidate, baseVersion) => {
+                const { root } = await this.persist(candidate, baseVersion);
+                this.setSourceRoot(this._sourceUri, root);
+            },
+            refetch: () => this.refetch(),
+            baseline: this.baseline,
+            conflictResolver: this.conflictResolver,
+            logger: this.logger,
+            onConflictDropped: () => this.refreshSourceRoot()
+        });
+    }
+    /**
+     * Write hook — secondaries first (ungated), primary last (gated on
+     * `baseVersion`). The order is the failure-mode choice documented on the
+     * class, not incidental: override this when the primary is the document the
+     * others REFERENCE, since then this order writes the references first.
+     */
+    async persist(model, baseVersion) {
+        for (const [uri, secondary] of Object.entries(model.secondaries)) {
+            if (this.hasChanged(this.baseline?.secondaries[uri], secondary)) {
+                await this.persistSecondary(uri, secondary);
+            }
+        }
+        if (!this.hasChanged(this.baseline?.primary, model.primary)) {
+            // Nothing to write, so nothing to gate either — return the root already
+            // captured rather than round-tripping the document for no reason.
+            return { root: this._sourceRoot };
+        }
+        return this.persistPrimary(model.primary, baseVersion);
+    }
+    /**
+     * Whether `candidate` differs from the baseline projection of the same
+     * document, and therefore needs writing.
+     *
+     * **Skipping unchanged documents is correctness, not an optimisation.** A
+     * write goes through `ModelService.update`, which re-serializes from the AST —
+     * so writing a document that did not change still rewrites its text, and a
+     * serializer is free to normalise formatting and cannot preserve comments.
+     * Persisting the whole write set unconditionally therefore means a pure layout
+     * drag reflows the semantic file and strips its comments, which is a data
+     * loss the user never asked for and would struggle to attribute.
+     *
+     * Compared by serialised form. Both sides come from the same encoder walking
+     * the same shape, so key order is stable and a string compare is sound here;
+     * it is also cheap enough to run per document per write.
+     */
+    hasChanged(baseline, candidate) {
+        return baseline === undefined || JSON.stringify(baseline) !== JSON.stringify(candidate);
+    }
+    /** Write the primary document, opting into the conflict gate when `baseVersion` is given. */
+    async persistPrimary(model, baseVersion) {
+        const document = await this.sharedServices.model.ModelService.update({
+            uri: this._sourceUri,
+            model,
+            clientId: this.clientId,
+            baseVersion
+        });
+        return document;
+    }
+    /**
+     * Write one secondary document. Ungated by design (see the class doc); override
+     * alongside {@link persistPrimary} when the round-trip differs per document
+     * role — a layout file and a semantic file need not share a serializer.
+     */
+    async persistSecondary(uri, model) {
+        await this.sharedServices.model.ModelService.update({ uri, model, clientId: this.clientId });
+    }
+    /**
+     * Refetch hook — the current settled projection across the write set, used by
+     * the conflict resolver to replay the user's intent against fresh state.
+     * Returns `undefined` when the PRIMARY cannot be read, since a reconcile
+     * without it has nothing to merge into; an unreadable secondary is omitted the
+     * same way {@link sourceModel} omits one.
+     */
+    async refetch() {
+        const fresh = await this.sharedServices.model.ModelService.validated(this._sourceUri).catch(() => undefined);
+        if (!fresh) {
+            return undefined;
+        }
+        const secondaries = {};
+        for (const uri of this.secondaryUris) {
+            const settled = await this.sharedServices.model.ModelService.validated(uri).catch(() => undefined);
+            if (settled) {
+                secondaries[uri] = this.projectRoot(settled.root);
+            }
+        }
+        return { primary: this.projectRoot(fresh.root), secondaries };
+    }
+    /** Project a currently-loaded document's root, or `undefined` when it is not loaded. */
+    projectDocument(uri) {
+        const root = this.sharedServices.model.ModelService.getDocument(uri)?.parseResult?.value;
+        return root ? this.projectRoot(root) : undefined;
+    }
+    /** Grammar-mode transfer projection of one AST root. The single projection seam. */
+    projectRoot(root) {
+        return this.sharedServices.model.TransferEncoder.toTransfer(root, 'grammar');
+    }
+};
+ReconcilingMultiDocumentGlspState = __decorate([
+    injectable()
+], ReconcilingMultiDocumentGlspState);
+export { ReconcilingMultiDocumentGlspState };
+//# sourceMappingURL=reconciling-multi-document-glsp-state.js.map

package/lib/state/reconciling-multi-document-glsp-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciling-multi-document-glsp-state.js","sourceRoot":"","sources":["../../src/state/reconciling-multi-document-glsp-state.ts"],"names":[],"mappings":"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"}

package/lib/state/reconciling-transfer-hydranium-glsp-state.d.ts

@@ -0,0 +1,91 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type JsonModelState } from '@eclipse-glsp/server';
+import { type AstNode } from '@hydranium/langium';
+import { type TransferElement } from '@hydranium/protocol';
+import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+/**
+ * Editable GLSP state for adopters whose source model is a **structured
+ * transfer-model projection** round-tripped through the language
+ * `ModelService`. Adds the forward-write
+ * reconcile machinery on top of the slim {@link AbstractHydraniumGlspState} base:
+ *
+ * - {@link sourceModel} — the persisted-shape projection of the current
+ *   source root, produced by the framework
+ *   `TransferEncoder` in `'grammar'` mode
+ *   (grammar-declared properties only; computed / synthetic excluded). The
+ *   field-level shape is what lets `fast-json-patch` diff per field, so undo /
+ *   redo and forward-write reconcile act per field instead of clobbering the
+ *   whole document.
+ * - {@link baseline} — the last in-sync projection, captured on every
+ *   {@link setSourceRoot}. A forward-write conflict reconciles the user's
+ *   intent (baseline → attempted) against the fresh server root.
+ * - {@link updateSourceModel} — the concrete reconcile template: persist,
+ *   and on a `ConflictError` consult the injected `conflictResolver` and act
+ *   on the merged / no-op / conflict / unavailable outcome.
+ * - {@link persist} / {@link refetch} — the only I/O seams. Defaults route
+ *   through `ModelService.update` / `.validated` (reachable from the base via
+ *   `sharedServices.model`); adopters whose document round-trip differs
+ *   override these without touching the orchestration.
+ *
+ * Adopters whose source model is whole-document text (a bare `{ text }`
+ * source model) or that are read-only do NOT extend this class — they extend
+ * {@link AbstractHydraniumGlspState} directly and supply their own `updateSourceModel`
+ * (or throw). The conflict-resolution *policy* (reconcile vs force) is still
+ * the base's injected `conflictResolver`; this class owns the forward-write
+ * *orchestration* that consults it.
+ */
+export declare class ReconcilingTransferHydraniumGlspState<TRoot extends AstNode, TSourceModel extends TransferElement> extends AbstractHydraniumGlspState<TRoot, TSourceModel> implements JsonModelState<TSourceModel> {
+    /**
+     * Last in-sync source-model projection, captured on every
+     * {@link setSourceRoot} (initial load + post-update). The baseline a
+     * forward-write conflict reconciles against: it stays the pre-command
+     * state because operation handlers mutate `_sourceRoot` in place during
+     * `execute` while `setSourceRoot` only re-runs once the write commits.
+     */
+    protected baseline?: TSourceModel;
+    /**
+     * Persisted-shape projection of the current source root, consumed by GLSP's
+     * {@link JsonModelState} read side and recorded for field-level undo / redo.
+     * Produced by the framework `TransferEncoder` in `'grammar'` mode
+     * (cross-references → `$refText`, Langium internals + computed / synthetic
+     * properties excluded), so the diff reflects only authored state.
+     * Synchronous — the encoder walks the in-memory AST without serialising.
+     */
+    get sourceModel(): TSourceModel;
+    setSourceRoot(uri: string, root: TRoot): void;
+    /**
+     * Persist `model` back to the document store, then capture the resulting
+     * AST root. On a `ConflictError` (the based-on version was superseded),
+     * reconcile the user's intent against the fresh server root via the bound
+     * `conflictResolver` and act on the outcome — one declarative policy
+     * (force = last-writer-wins, reconciling = field-level merge) shared with
+     * undo / redo.
+     */
+    updateSourceModel(model: TSourceModel, version?: number): Promise<void>;
+    /**
+     * Persist hook — the only write-side I/O. Default routes the structured
+     * model through `ModelService.update` (serialize → reparse), opting into
+     * the `ConflictError` gate when `version` is given. Adopters whose document
+     * round-trip differs override this; the orchestration in
+     * {@link updateSourceModel} is unchanged.
+     */
+    protected persist(model: TSourceModel, baseVersion?: number): Promise<{
+        root: TRoot;
+    }>;
+    /**
+     * Refetch hook — reads the current settled server root as a persisted-shape
+     * projection (or `undefined` when unavailable). The `conflictResolver`
+     * replays the user's intent against this fresh state. Default uses
+     * `ModelService.validated` + the framework encoder's `'grammar'` mode;
+     * adopters override alongside {@link persist}.
+     */
+    protected refetch(): Promise<TSourceModel | undefined>;
+}
+//# sourceMappingURL=reconciling-transfer-hydranium-glsp-state.d.ts.map

package/lib/state/reconciling-transfer-hydranium-glsp-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciling-transfer-hydranium-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/reconciling-transfer-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,qCAAqC,CAAC,KAAK,SAAS,OAAO,EAAE,YAAY,SAAS,eAAe,CAC3G,SAAQ,0BAA0B,CAAC,KAAK,EAAE,YAAY,CACtD,YAAW,cAAc,CAAC,YAAY,CAAC;IAEvC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IAElC;;;;;;;OAOG;IACH,IAAI,WAAW,IAAI,YAAY,CAE9B;IAEQ,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;IAKtD;;;;;;;OAOG;IACG,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB7E;;;;;;OAMG;cACa,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC;IAU5F;;;;;;OAMG;cACa,OAAO,IAAI,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;CAI9D"}

package/lib/state/reconciling-transfer-hydranium-glsp-state.js

@@ -0,0 +1,129 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+import { reconcileSourceModelWrite } from './reconcile-source-model-write.js';
+/**
+ * Editable GLSP state for adopters whose source model is a **structured
+ * transfer-model projection** round-tripped through the language
+ * `ModelService`. Adds the forward-write
+ * reconcile machinery on top of the slim {@link AbstractHydraniumGlspState} base:
+ *
+ * - {@link sourceModel} — the persisted-shape projection of the current
+ *   source root, produced by the framework
+ *   `TransferEncoder` in `'grammar'` mode
+ *   (grammar-declared properties only; computed / synthetic excluded). The
+ *   field-level shape is what lets `fast-json-patch` diff per field, so undo /
+ *   redo and forward-write reconcile act per field instead of clobbering the
+ *   whole document.
+ * - {@link baseline} — the last in-sync projection, captured on every
+ *   {@link setSourceRoot}. A forward-write conflict reconciles the user's
+ *   intent (baseline → attempted) against the fresh server root.
+ * - {@link updateSourceModel} — the concrete reconcile template: persist,
+ *   and on a `ConflictError` consult the injected `conflictResolver` and act
+ *   on the merged / no-op / conflict / unavailable outcome.
+ * - {@link persist} / {@link refetch} — the only I/O seams. Defaults route
+ *   through `ModelService.update` / `.validated` (reachable from the base via
+ *   `sharedServices.model`); adopters whose document round-trip differs
+ *   override these without touching the orchestration.
+ *
+ * Adopters whose source model is whole-document text (a bare `{ text }`
+ * source model) or that are read-only do NOT extend this class — they extend
+ * {@link AbstractHydraniumGlspState} directly and supply their own `updateSourceModel`
+ * (or throw). The conflict-resolution *policy* (reconcile vs force) is still
+ * the base's injected `conflictResolver`; this class owns the forward-write
+ * *orchestration* that consults it.
+ */
+let ReconcilingTransferHydraniumGlspState = class ReconcilingTransferHydraniumGlspState extends AbstractHydraniumGlspState {
+    /**
+     * Last in-sync source-model projection, captured on every
+     * {@link setSourceRoot} (initial load + post-update). The baseline a
+     * forward-write conflict reconciles against: it stays the pre-command
+     * state because operation handlers mutate `_sourceRoot` in place during
+     * `execute` while `setSourceRoot` only re-runs once the write commits.
+     */
+    baseline;
+    /**
+     * Persisted-shape projection of the current source root, consumed by GLSP's
+     * {@link JsonModelState} read side and recorded for field-level undo / redo.
+     * Produced by the framework `TransferEncoder` in `'grammar'` mode
+     * (cross-references → `$refText`, Langium internals + computed / synthetic
+     * properties excluded), so the diff reflects only authored state.
+     * Synchronous — the encoder walks the in-memory AST without serialising.
+     */
+    get sourceModel() {
+        return this.sharedServices.model.TransferEncoder.toTransfer(this._sourceRoot, 'grammar');
+    }
+    setSourceRoot(uri, root) {
+        super.setSourceRoot(uri, root);
+        this.baseline = this.sourceModel;
+    }
+    /**
+     * Persist `model` back to the document store, then capture the resulting
+     * AST root. On a `ConflictError` (the based-on version was superseded),
+     * reconcile the user's intent against the fresh server root via the bound
+     * `conflictResolver` and act on the outcome — one declarative policy
+     * (force = last-writer-wins, reconciling = field-level merge) shared with
+     * undo / redo.
+     */
+    async updateSourceModel(model, version) {
+        // Orchestration lives in `reconcileSourceModelWrite` so the multi-document
+        // state gets the identical conflict handling; this method supplies only
+        // the single-document meaning of persist / project.
+        return reconcileSourceModelWrite(model, version, {
+            persist: async (candidate, baseVersion) => {
+                const { root } = await this.persist(candidate, baseVersion);
+                this.setSourceRoot(this._sourceUri, root);
+            },
+            refetch: () => this.refetch(),
+            baseline: this.baseline,
+            conflictResolver: this.conflictResolver,
+            logger: this.logger,
+            onConflictDropped: () => this.refreshSourceRoot()
+        });
+    }
+    /**
+     * Persist hook — the only write-side I/O. Default routes the structured
+     * model through `ModelService.update` (serialize → reparse), opting into
+     * the `ConflictError` gate when `version` is given. Adopters whose document
+     * round-trip differs override this; the orchestration in
+     * {@link updateSourceModel} is unchanged.
+     */
+    async persist(model, baseVersion) {
+        const document = await this.sharedServices.model.ModelService.update({
+            uri: this._sourceUri,
+            model,
+            clientId: this.clientId,
+            baseVersion
+        });
+        return document;
+    }
+    /**
+     * Refetch hook — reads the current settled server root as a persisted-shape
+     * projection (or `undefined` when unavailable). The `conflictResolver`
+     * replays the user's intent against this fresh state. Default uses
+     * `ModelService.validated` + the framework encoder's `'grammar'` mode;
+     * adopters override alongside {@link persist}.
+     */
+    async refetch() {
+        const fresh = await this.sharedServices.model.ModelService.validated(this._sourceUri).catch(() => undefined);
+        return fresh ? this.sharedServices.model.TransferEncoder.toTransfer(fresh.root, 'grammar') : undefined;
+    }
+};
+ReconcilingTransferHydraniumGlspState = __decorate([
+    injectable()
+], ReconcilingTransferHydraniumGlspState);
+export { ReconcilingTransferHydraniumGlspState };
+//# sourceMappingURL=reconciling-transfer-hydranium-glsp-state.js.map

package/lib/state/reconciling-transfer-hydranium-glsp-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciling-transfer-hydranium-glsp-state.js","sourceRoot":"","sources":["../../src/state/reconciling-transfer-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvC,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEI,IAAM,qCAAqC,GAA3C,MAAM,qCACV,SAAQ,0BAA+C;IAGvD;;;;;;OAMG;IACO,QAAQ,CAAgB;IAElC;;;;;;;OAOG;IACH,IAAI,WAAW;QACZ,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,SAAS,CAA4B,CAAC;IACvH,CAAC;IAEQ,aAAa,CAAC,GAAW,EAAE,IAAW;QAC5C,KAAK,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;IACpC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,iBAAiB,CAAC,KAAmB,EAAE,OAAgB;QAC1D,2EAA2E;QAC3E,wEAAwE;QACxE,oDAAoD;QACpD,OAAO,yBAAyB,CAAe,KAAK,EAAE,OAAO,EAAE;YAC5D,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE;gBACvC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;gBAC5D,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAC7C,CAAC;YACD,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,iBAAiB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE;SACnD,CAAC,CAAC;IACN,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,OAAO,CAAC,KAAmB,EAAE,WAAoB;QAC9D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC;YAClE,GAAG,EAAE,IAAI,CAAC,UAAU;YACpB,KAAK;YACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW;SACb,CAAC,CAAC;QACH,OAAO,QAAsC,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,OAAO;QACpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC7G,OAAO,KAAK,CAAC,CAAC,CAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAA6B,CAAC,CAAC,CAAC,SAAS,CAAC;IACvI,CAAC;CACH,CAAA;AAnFY,qCAAqC;IADjD,UAAU,EAAE;GACA,qCAAqC,CAmFjD"}