@vscode/markdown-editor 0.0.2-0

package/dist/model/cursorNavigation.d.ts

@@ -0,0 +1,7 @@
+import { BlockAstNode, DocumentAstNode, ListAstNode } from '../parser/ast.js';
+/**
+ * Move the cursor one position left or right, skipping over hidden marker
+ * ranges in inactive blocks (and inactive items of an active list).
+ */
+export declare function nextCursorPosition(doc: DocumentAstNode, activeBlock: BlockAstNode | undefined, cursor: number, direction: 'left' | 'right'): number;
+export declare function findActiveListItemIndex(list: ListAstNode, cursorOffset: number): number | undefined;

package/dist/model/editorModel.d.ts

@@ -0,0 +1,54 @@
+import { StringValue } from '../core/stringValue.js';
+import { StringEdit } from '../core/stringEdit.js';
+import { Selection } from '../core/selection.js';
+import { BlockAstNode, DocumentAstNode } from '../parser/ast.js';
+export declare const NO_ACTIVE_BLOCKS: unique symbol;
+export declare class EditorModel {
+    private readonly _parser;
+    /**
+     * The most recent edit applied to {@link sourceText}, used by
+     * {@link document} to let the parser link incrementally edited code
+     * blocks. Only trusted when it exactly bridges the previous and current
+     * source text (see {@link document}).
+     */
+    private _pendingEdit;
+    readonly sourceText: import('@vscode/observables').ISettableObservable<StringValue, void>;
+    /**
+     * The current selection, or `undefined` when the editor has no caret
+     * (e.g. an inactive/unfocused rendering).
+     */
+    readonly selection: import('@vscode/observables').ISettableObservable<Selection | undefined, void>;
+    /**
+     * Forces the rendered active-block set. `undefined` (the default)
+     * derives the set from the current selection range (see
+     * {@link activeBlocks}). The sentinel {@link NO_ACTIVE_BLOCKS} forces
+     * "no active block" — useful in fixtures that always want the
+     * collapsed/inactive rendering.
+     */
+    readonly activeBlocksOverride: import('@vscode/observables').ISettableObservable<readonly BlockAstNode[] | typeof NO_ACTIVE_BLOCKS | undefined, void>;
+    readonly cursorOffset: import('@vscode/observables').IObservableWithChange<number | undefined, void>;
+    /**
+     * The parsed document. Threads the previous document into the parser so
+     * unchanged blocks keep their object identity across reparses (see
+     * {@link MarkdownParser.parse}). Writing `previous` inside the compute is
+     * a safe optimization: `derived` only recomputes when `sourceText`
+     * changes, and the result is structurally identical to a full reparse.
+     */
+    readonly document: import('@vscode/observables').IObservableWithChange<DocumentAstNode, void>;
+    /**
+     * Block that contains the cursor (selection's active end). Used by
+     * cursor navigation to know which block's marker ranges count as
+     * visible. Unaffected by {@link activeBlocksOverride} because
+     * navigation is independent of rendering.
+     */
+    readonly activeBlock: import('@vscode/observables').IObservableWithChange<BlockAstNode | undefined, void>;
+    /**
+     * All blocks whose source range intersects the current selection.
+     * The rendering side uses this to decide which blocks render in
+     * their expanded (markers-visible) form. When the selection is
+     * collapsed this is a one-element set holding {@link activeBlock}.
+     */
+    readonly activeBlocks: import('@vscode/observables').IObservableWithChange<Set<BlockAstNode>, void>;
+    applyEdit(edit: StringEdit): void;
+    applyEditForSelection(edit: StringEdit): void;
+}

package/dist/model/index.d.ts

@@ -0,0 +1,4 @@
+export { EditorModel } from './editorModel.js';
+export { MeasuredLayoutModel, type BlockMeasurement } from './measuredLayoutModel.js';
+export { nextCursorPosition } from './cursorNavigation.js';
+export { Selection } from '../core/selection.js';

package/dist/model/measuredLayoutModel.d.ts

@@ -0,0 +1,50 @@
+import { BlockAstNode } from '../parser/ast.js';
+import { ViewNode } from '../view/content/viewNode.js';
+import { VisualLineMap } from '../view/visualLineMap.js';
+/**
+ * One block's place in the rendered document.
+ *
+ * `height` is in CSS pixels. It is either a real DOM measurement
+ * (`isMeasured: true`) or an estimate produced when the block is not
+ * currently mounted (`isMeasured: false`). Estimates exist so virtual
+ * rendering can size the scroll container without mounting every block.
+ *
+ * `visualLineMap` and `viewNode` are set only when the block is mounted
+ * and measured. Cursor positioning, selection painting and up/down
+ * navigation read through `visualLineMap`; the debug view walks
+ * `viewNode` to enumerate text leaves for per-character introspection.
+ * Unmeasured blocks have neither.
+ */
+export interface BlockMeasurement {
+    readonly block: BlockAstNode;
+    readonly absoluteStart: number;
+    readonly height: number;
+    readonly isMeasured: boolean;
+    readonly visualLineMap: VisualLineMap | undefined;
+    readonly viewNode: ViewNode | undefined;
+}
+/**
+ * The set of measurements/estimates the view has produced for the current
+ * document. This is the "view → derived facts about layout" channel: the
+ * view writes here as a side effect of rendering and measuring; the
+ * controller (and selection/cursor rendering) reads from here.
+ *
+ * Keeping these facts in their own observable model — instead of as ad-hoc
+ * fields on the view — preserves the invariant
+ *
+ *     view(model + Δ) = view(model) + Δ
+ *
+ * i.e. the view becomes a pure function of (EditorModel, MeasuredLayoutModel).
+ * Everything else that depends on layout (controller, commands) goes
+ * through this model and never touches view fields directly.
+ */
+export declare class MeasuredLayoutModel {
+    readonly measurements: import('@vscode/observables').ISettableObservable<readonly BlockMeasurement[], void>;
+    /**
+     * Concatenated visual line map across all mounted blocks. Lines are
+     * left in DOM (client-coordinate) y order — each per-block map already
+     * uses absolute client coordinates from `getClientRects()`, so the
+     * concatenation is well-formed without re-sorting.
+     */
+    readonly visualLineMap: import('@vscode/observables').IObservableWithChange<VisualLineMap, void>;
+}

package/dist/observables.d.ts

@@ -0,0 +1 @@
+export * from '@vscode/observables';

package/dist/observables.js

@@ -0,0 +1,463 @@
+import { B as w, T, g as C, b as u, s as c, O as E, c as v, o as V, d as _, t as g, e as k, a as S, C as O, f as z, h as b, i as W, j as D, k as N, l as P, m as R, n as q, p as L } from "./runOnChange-owE1SMC0.js";
+import { D as de, q as oe, u as ue, v as he, w as le, x as be, y as fe, z as ce, A as ge, E as ve, F as _e, G as pe, H as me, I as Ce, J as Oe, K as ye, L as we, M as Ve, N as Se, P as De, Q as Ue, R as Fe, S as Te, r as Ee, U as ke, V as ze, W as We, X as Ne, Y as Pe } from "./runOnChange-owE1SMC0.js";
+class H extends w {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "LazyObservableValue";
+  }
+  constructor(e, t, s, r) {
+    super(r), this._debugNameData = e, this._equalityComparator = s, this._isUpToDate = !0, this._deltas = [], this._updateCounter = 0, this._value = t;
+  }
+  get() {
+    return this._update(), this._value;
+  }
+  _update() {
+    if (!this._isUpToDate)
+      if (this._isUpToDate = !0, this._deltas.length > 0) {
+        for (const e of this._deltas) {
+          C()?.handleObservableUpdated(this, { change: e, didChange: !0, oldValue: "(unknown)", newValue: this._value, hadValue: !0 });
+          for (const t of this._observers)
+            t.handleChange(this, e);
+        }
+        this._deltas.length = 0;
+      } else {
+        C()?.handleObservableUpdated(this, { change: void 0, didChange: !0, oldValue: "(unknown)", newValue: this._value, hadValue: !0 });
+        for (const e of this._observers)
+          e.handleChange(this, void 0);
+      }
+  }
+  _beginUpdate() {
+    if (this._updateCounter++, this._updateCounter === 1)
+      for (const e of this._observers)
+        e.beginUpdate(this);
+  }
+  _endUpdate() {
+    if (this._updateCounter--, this._updateCounter === 0) {
+      this._update();
+      const e = [...this._observers];
+      for (const t of e)
+        t.endUpdate(this);
+    }
+  }
+  addObserver(e) {
+    const t = !this._observers.has(e) && this._updateCounter > 0;
+    super.addObserver(e), t && e.beginUpdate(this);
+  }
+  removeObserver(e) {
+    const t = this._observers.has(e) && this._updateCounter > 0;
+    super.removeObserver(e), t && e.endUpdate(this);
+  }
+  set(e, t, s) {
+    if (s === void 0 && this._equalityComparator(this._value, e))
+      return;
+    let r;
+    t || (t = r = new T(() => {
+    }, () => `Setting ${this.debugName}`));
+    try {
+      if (this._isUpToDate = !1, this._setValue(e), s !== void 0 && this._deltas.push(s), t.updateObserver({
+        beginUpdate: () => this._beginUpdate(),
+        endUpdate: () => this._endUpdate(),
+        handleChange: (n, i) => {
+        },
+        handlePossibleChange: (n) => {
+        }
+      }, this), this._updateCounter > 1)
+        for (const n of this._observers)
+          n.handlePossibleChange(this);
+    } finally {
+      r && r.finish();
+    }
+  }
+  toString() {
+    return `${this.debugName}: ${this._value}`;
+  }
+  _setValue(e) {
+    this._value = e;
+  }
+}
+function U(a, e, t = v.ofCaller()) {
+  return a.lazy ? new H(new u(a.owner, a.debugName, void 0), e, a.equalsFn ?? c, t) : new E(new u(a.owner, a.debugName, void 0), e, a.equalsFn ?? c, t);
+}
+class I {
+  /**
+   * The cached value.
+   * Does not force a computation of the value.
+   */
+  get cachedValue() {
+    return this._value;
+  }
+  constructor(e) {
+    this._computeValue = e, this._value = V(this, void 0);
+  }
+  /**
+   * Returns the cached value.
+   * Computes the value if the value has not been cached yet.
+   */
+  getValue() {
+    let e = this._value.get();
+    return e || (e = this._computeValue(), this._value.set(e, void 0)), e;
+  }
+}
+class p {
+  static fromFn(e) {
+    return new p(e());
+  }
+  constructor(e) {
+    this._value = V(this, void 0), this.promiseResult = this._value, this.resolvedValue = _(this, (t) => {
+      const s = this.promiseResult.read(t);
+      if (s)
+        return s.getDataOrThrow();
+    }), this.promise = e.then((t) => (g((s) => {
+      this._value.set(new y(t, void 0), s);
+    }), t), (t) => {
+      throw g((s) => {
+        this._value.set(new y(void 0, t), s);
+      }), t;
+    });
+  }
+}
+class y {
+  constructor(e, t) {
+    this.data = e, this.error = t;
+  }
+  /**
+   * Returns the value if the promise resolved, otherwise throws the error.
+   */
+  getDataOrThrow() {
+    if (this.error)
+      throw this.error;
+    return this.data;
+  }
+}
+class G {
+  constructor(e) {
+    this._computePromise = e, this._lazyValue = new I(() => new p(this._computePromise())), this.cachedPromiseResult = _(this, (t) => this._lazyValue.cachedValue.read(t)?.promiseResult.read(t));
+  }
+  getPromise() {
+    return this._lazyValue.getValue().promise;
+  }
+}
+function J(a, e, t, s) {
+  return e || (e = (r) => r != null), new Promise((r, n) => {
+    let i = !0, d = !1;
+    const f = a.map((o) => ({
+      isFinished: e(o),
+      error: t ? t(o) : !1,
+      state: o
+    })), h = S((o) => {
+      const { isFinished: F, error: l, state: m } = f.read(o);
+      (F || l) && (i ? d = !0 : h.dispose(), l ? n(l === !0 ? m : l) : r(m));
+    });
+    if (s) {
+      const o = s.onCancellationRequested(() => {
+        h.dispose(), o.dispose(), n(new O());
+      });
+      if (s.isCancellationRequested) {
+        h.dispose(), o.dispose(), n(new O());
+        return;
+      }
+    }
+    i = !1, d && h.dispose();
+  });
+}
+function Q(a, e) {
+  let t, s;
+  e === void 0 ? (t = a, s = void 0) : (s = a, t = e);
+  let r;
+  return new k(new u(s, void 0, t), (n) => (r && r.dispose(), r = new z(), t(n, r.token)), void 0, () => r?.dispose(), c, v.ofCaller());
+}
+function X(a) {
+  return {
+    createChangeSummary: (e) => ({
+      changes: []
+    }),
+    handleChange(e, t) {
+      for (const s in a)
+        e.didChange(a[s]) && t.changes.push({ key: s, change: e.change });
+      return !0;
+    },
+    beforeUpdate(e, t) {
+      for (const s in a) {
+        if (s === "changes")
+          throw new b('property name "changes" is reserved for change tracking');
+        t[s] = a[s].read(e);
+      }
+    }
+  };
+}
+function Y(a) {
+  let e;
+  return {
+    createChangeSummary: (t) => ({
+      changes: []
+    }),
+    handleChange(t, s) {
+      e || (e = a());
+      for (const r in e)
+        t.didChange(e[r]) && s.changes.push({ key: r, change: t.change });
+      return !0;
+    },
+    beforeUpdate(t, s) {
+      e || (e = a());
+      for (const r in e) {
+        if (r === "changes")
+          throw new b('property name "changes" is reserved for change tracking');
+        s[r] = e[r].read(t);
+      }
+    }
+  };
+}
+function Z(a) {
+  return new A(a);
+}
+class A extends W {
+  constructor(e) {
+    super(), this.value = e;
+  }
+  get debugName() {
+    return this.toString();
+  }
+  get() {
+    return this.value;
+  }
+  addObserver(e) {
+  }
+  removeObserver(e) {
+  }
+  log() {
+    return this;
+  }
+  toString() {
+    return `Const: ${this.value}`;
+  }
+}
+function B(a, e, t = v.ofCaller()) {
+  return new M(typeof a == "string" ? a : new u(a, void 0, void 0), e, t);
+}
+class M extends w {
+  constructor(e, t, s) {
+    super(s), this.event = t, this.handleEvent = () => {
+      g((r) => {
+        for (const n of this._observers)
+          r.updateObserver(n, this), n.handleChange(this, void 0);
+      }, () => this.debugName);
+    }, this.debugName = typeof e == "string" ? e : e.getDebugName(this) ?? "Observable Signal From Event";
+  }
+  onFirstObserverAdded() {
+    this.subscription = this.event(this.handleEvent);
+  }
+  onLastObserverRemoved() {
+    this.subscription.dispose(), this.subscription = void 0;
+  }
+  get() {
+  }
+}
+function $(a) {
+  return (e) => {
+    let t = !0;
+    return S((s) => {
+      a.read(s), t ? t = !1 : e();
+    });
+  };
+}
+class x {
+  constructor(e) {
+    this.observable = e;
+  }
+  get onDidChange() {
+    return $(this.observable);
+  }
+  get value() {
+    return this.observable.get();
+  }
+}
+function j(a, e) {
+  return e instanceof x ? e.observable : D(a, e.onDidChange, () => e.value);
+}
+function ee(a, e) {
+  if (e.length === 0)
+    throw new b();
+  let t = !1, s;
+  const r = D(a, (n) => {
+    const i = new P();
+    for (const d of e)
+      i.add(R({ debugName: () => q(r, new u(a, void 0, void 0)) + ".updateLastChangedValue" }, (f) => {
+        t = !0, s = d.read(f), n();
+      }));
+    return i.add({
+      dispose() {
+        t = !1, s = void 0;
+      }
+    }), i;
+  }, () => t ? s : e[e.length - 1].get());
+  return r;
+}
+function te(a, e) {
+  return N(a, (t, s) => s ?? e(t));
+}
+function se(a, e, t) {
+  let s, r, n = !1;
+  const i = B("deferUnobserve", (d) => {
+    if (n)
+      throw new b("deferUnobserve: Cannot add observer after disposal");
+    return r !== void 0 && (clearTimeout(r), r = void 0), s || (s = L(e)), {
+      dispose() {
+        r = setTimeout(() => {
+          r = void 0, s?.dispose(), s = void 0;
+        }, t);
+      }
+    };
+  });
+  return a.add({
+    dispose() {
+      r !== void 0 && (clearTimeout(r), r = void 0), s?.dispose(), s = void 0, n = !0;
+    }
+  }), _((d) => (i.read(d), e.read(d)));
+}
+class ae {
+  constructor() {
+    this._data = /* @__PURE__ */ new Set(), this._obs = U({ equalsFn: () => !1 }, this), this.observable = this._obs;
+  }
+  get size() {
+    return this._data.size;
+  }
+  has(e) {
+    return this._data.has(e);
+  }
+  add(e, t) {
+    return this._data.has(e) || (this._data.add(e), this._obs.set(this, t)), this;
+  }
+  delete(e, t) {
+    const s = this._data.delete(e);
+    return s && this._obs.set(this, t), s;
+  }
+  clear(e) {
+    this._data.size > 0 && (this._data.clear(), this._obs.set(this, e));
+  }
+  forEach(e, t) {
+    this._data.forEach((s, r, n) => {
+      e.call(t, s, r, this);
+    });
+  }
+  *entries() {
+    for (const e of this._data)
+      yield [e, e];
+  }
+  *keys() {
+    yield* this._data.keys();
+  }
+  *values() {
+    yield* this._data.values();
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  get [Symbol.toStringTag]() {
+    return "ObservableSet";
+  }
+}
+class re {
+  constructor() {
+    this._data = /* @__PURE__ */ new Map(), this._obs = U({ equalsFn: () => !1 }, this), this.observable = this._obs;
+  }
+  get size() {
+    return this._data.size;
+  }
+  has(e) {
+    return this._data.has(e);
+  }
+  get(e) {
+    return this._data.get(e);
+  }
+  set(e, t, s) {
+    const r = this._data.has(e), n = this._data.get(e);
+    return (!r || n !== t) && (this._data.set(e, t), this._obs.set(this, s)), this;
+  }
+  delete(e, t) {
+    const s = this._data.delete(e);
+    return s && this._obs.set(this, t), s;
+  }
+  clear(e) {
+    this._data.size > 0 && (this._data.clear(), this._obs.set(this, e));
+  }
+  forEach(e, t) {
+    this._data.forEach((s, r, n) => {
+      e.call(t, s, r, this);
+    });
+  }
+  *entries() {
+    yield* this._data.entries();
+  }
+  *keys() {
+    yield* this._data.keys();
+  }
+  *values() {
+    yield* this._data.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "ObservableMap";
+  }
+}
+export {
+  v as DebugLocation,
+  de as Disposable,
+  P as DisposableStore,
+  I as ObservableLazy,
+  G as ObservableLazyPromise,
+  re as ObservableMap,
+  p as ObservablePromise,
+  ae as ObservableSet,
+  y as PromiseResult,
+  T as TransactionImpl,
+  x as ValueWithChangeEventFromObservable,
+  oe as asyncTransaction,
+  S as autorun,
+  ue as autorunDelta,
+  he as autorunHandleChanges,
+  le as autorunIterableDelta,
+  R as autorunOpts,
+  be as autorunSelfDisposable,
+  fe as autorunWithStore,
+  ce as autorunWithStoreHandleChanges,
+  Z as constObservable,
+  ge as debouncedObservable,
+  ve as debouncedObservableDeprecated,
+  se as deferUnobserve,
+  _ as derived,
+  te as derivedConstOnceDefined,
+  _e as derivedDisposable,
+  pe as derivedHandleChanges,
+  N as derivedObservableWithCache,
+  me as derivedObservableWithWritableCache,
+  Ce as derivedOpts,
+  Q as derivedWithCancellationToken,
+  Oe as derivedWithSetter,
+  ye as derivedWithStore,
+  we as disposableObservableValue,
+  Ve as globalTransaction,
+  L as keepObserved,
+  ee as latestChangedValue,
+  Se as mapObservableArrayCached,
+  D as observableFromEvent,
+  De as observableFromEventOpts,
+  Ue as observableFromPromise,
+  j as observableFromValueWithChangeEvent,
+  Fe as observableSignal,
+  B as observableSignalFromEvent,
+  V as observableValue,
+  U as observableValueOpts,
+  Te as recomputeInitiallyAndOnChange,
+  X as recordChanges,
+  Y as recordChangesLazy,
+  Ee as runOnChange,
+  ke as runOnChangeWithCancellationToken,
+  ze as runOnChangeWithStore,
+  We as signalFromObservable,
+  Ne as subtransaction,
+  g as transaction,
+  J as waitForState,
+  Pe as wasEventTriggeredRecently
+};
+//# sourceMappingURL=observables.js.map