obsidian-dev-utils 18.4.0 → 19.0.0

package/dist/lib/obsidian/@types/Dataview/query/parse.d.mts

@@ -0,0 +1,44 @@
+import * as P from 'parsimmon';
+import type { Result } from '../api/result.d.mjs';
+import type { Source } from '../data-index/source.d.mjs';
+import type {
+  Comment,
+  FlattenStep,
+  GroupStep,
+  LimitStep,
+  NamedField,
+  Query,
+  QueryHeader,
+  QueryOperation,
+  QuerySortBy,
+  QueryType,
+  SortByStep,
+  WhereStep
+} from './query.d.mjs';
+/** Typings for the outputs of all of the parser combinators. */
+interface QueryLanguageTypes {
+  queryType: QueryType;
+  comment: Comment;
+  explicitNamedField: NamedField;
+  namedField: NamedField;
+  sortField: QuerySortBy;
+  headerClause: QueryHeader;
+  fromClause: Source;
+  whereClause: WhereStep;
+  sortByClause: SortByStep;
+  limitClause: LimitStep;
+  flattenClause: FlattenStep;
+  groupByClause: GroupStep;
+  clause: QueryOperation;
+  query: Query;
+}
+/** Return a new parser which executes the underlying parser and returns it's raw string representation. */
+export declare function captureRaw<T>(base: P.Parser<T>): P.Parser<[T, string]>;
+/** A parsimmon-powered parser-combinator implementation of the query language. */
+export declare const QUERY_LANGUAGE: P.TypedLanguage<QueryLanguageTypes>;
+/**
+ * Attempt to parse a query from the given query text, returning a string error
+ * if the parse failed.
+ */
+export declare function parseQuery(text: string): Result<Query, string>;
+export {};

package/dist/lib/obsidian/@types/Dataview/query/{query.d.ts → query.d.cts}

@@ -1,6 +1,6 @@
 /** Provides an AST for complex queries. */
-import type { Source } from '../data-index/source.d.ts';
-import type { Field } from '../expression/field.d.ts';
+import type { Source } from '../data-index/source.d.cjs';
+import type { Field } from '../expression/field.d.cjs';
 /** The supported query types (corresponding to view types). */
 export type QueryType = 'list' | 'table' | 'task' | 'calendar';
 /** A single-line comment. */

package/dist/lib/obsidian/@types/Dataview/query/query.d.mts

@@ -0,0 +1,95 @@
+/** Provides an AST for complex queries. */
+import type { Source } from '../data-index/source.d.mjs';
+import type { Field } from '../expression/field.d.mjs';
+/** The supported query types (corresponding to view types). */
+export type QueryType = 'list' | 'table' | 'task' | 'calendar';
+/** A single-line comment. */
+export type Comment = string;
+/** Fields used in the query portion. */
+export interface NamedField {
+  /** The effective name of this field. */
+  name: string;
+  /** The value of this field. */
+  field: Field;
+}
+/** A query sort by field, for determining sort order. */
+export interface QuerySortBy {
+  /** The field to sort on. */
+  field: Field;
+  /** The direction to sort in. */
+  direction: 'ascending' | 'descending';
+}
+/** Utility functions for quickly creating fields. */
+export declare namespace QueryFields {
+  function named(name: string, field: Field): NamedField;
+  function sortBy(field: Field, dir: 'ascending' | 'descending'): QuerySortBy;
+}
+/** A query which should render a list of elements. */
+export interface ListQuery {
+  type: 'list';
+  /** What should be rendered in the list. */
+  format?: Field;
+  /** If true, show the default DI field; otherwise, don't. */
+  showId: boolean;
+}
+/** A query which renders a table of elements. */
+export interface TableQuery {
+  type: 'table';
+  /** The fields (computed or otherwise) to select. */
+  fields: NamedField[];
+  /** If true, show the default ID field; otherwise, don't. */
+  showId: boolean;
+}
+/** A query which renders a collection of tasks. */
+export interface TaskQuery {
+  type: 'task';
+}
+/** A query which renders a collection of notes in a calendar view. */
+export interface CalendarQuery {
+  type: 'calendar';
+  /** The date field that we'll be grouping notes by for the calendar view */
+  field: NamedField;
+}
+export type QueryHeader = ListQuery | TableQuery | TaskQuery | CalendarQuery;
+/** A step which only retains rows whose 'clause' field is truthy. */
+export interface WhereStep {
+  type: 'where';
+  clause: Field;
+}
+/** A step which sorts all current rows by the given list of sorts. */
+export interface SortByStep {
+  type: 'sort';
+  fields: QuerySortBy[];
+}
+/** A step which truncates the number of rows to the given amount. */
+export interface LimitStep {
+  type: 'limit';
+  amount: Field;
+}
+/** A step which flattens rows into multiple child rows. */
+export interface FlattenStep {
+  type: 'flatten';
+  field: NamedField;
+}
+/** A step which groups rows into groups by the given field. */
+export interface GroupStep {
+  type: 'group';
+  field: NamedField;
+}
+/** A virtual step which extracts an array of values from each row. */
+export interface ExtractStep {
+  type: 'extract';
+  fields: Record<string, Field>;
+}
+export type QueryOperation = WhereStep | SortByStep | LimitStep | FlattenStep | GroupStep | ExtractStep;
+/**
+ * A query over the Obsidian database. Queries have a specific and deterministic execution order:
+ */
+export interface Query {
+  /** The view type to render this query in. */
+  header: QueryHeader;
+  /** The source that file candidates will come from. */
+  source: Source;
+  /** The operations to apply to the data to produce the final result that will be rendered. */
+  operations: QueryOperation[];
+}

package/dist/lib/obsidian/@types/Dataview/settings.d.mts

@@ -0,0 +1,60 @@
+export interface QuerySettings {
+  /** What to render 'null' as in tables. Defaults to '-'. */
+  renderNullAs: string;
+  /** If enabled, tasks in Dataview views will automatically have their completion date appended when they are checked. */
+  taskCompletionTracking: boolean;
+  /** If enabled, automatic completions will use emoji shorthand ✅ YYYY-MM-DD instead of [completion:: date]. */
+  taskCompletionUseEmojiShorthand: boolean;
+  /** The name of the inline field to be added as a task's completion when checked. Only used if completionTracking is enabled and emojiShorthand is not. */
+  taskCompletionText: string;
+  /** Date format of the task's completion timestamp. Only used if completionTracking is enabled and emojiShorthand is not. */
+  taskCompletionDateFormat: string;
+  /** Whether or not subtasks should be recursively completed in addition to their parent task. */
+  recursiveSubTaskCompletion: boolean;
+  /** If true, render a modal which shows no results were returned. */
+  warnOnEmptyResult: boolean;
+  /** Whether or not automatic view refreshing is enabled. */
+  refreshEnabled: boolean;
+  /** The interval that views are refreshed, by default. */
+  refreshInterval: number;
+  /** The default format that dates are rendered in (using luxon's moment-like formatting). */
+  defaultDateFormat: string;
+  /** The default format that date-times are rendered in (using luxon's moment-like formatting). */
+  defaultDateTimeFormat: string;
+  /** Maximum depth that objects will be expanded when being rendered recursively. */
+  maxRecursiveRenderDepth: number;
+  /** The name of the default ID field ('File'). */
+  tableIdColumnName: string;
+  /** The name of default ID fields on grouped data ('Group'). */
+  tableGroupColumnName: string;
+  /** Include the result count as part of the output. */
+  showResultCount: boolean;
+}
+export declare const DEFAULT_QUERY_SETTINGS: QuerySettings;
+export interface ExportSettings {
+  /** Whether or not HTML should be used for formatting in exports. */
+  allowHtml: boolean;
+}
+export declare const DEFAULT_EXPORT_SETTINGS: ExportSettings;
+export interface DataviewSettings extends QuerySettings, ExportSettings {
+  /** The prefix for inline queries by default. */
+  inlineQueryPrefix: string;
+  /** The prefix for inline JS queries by default. */
+  inlineJsQueryPrefix: string;
+  /** If true, inline queries are also evaluated in full codeblocks. */
+  inlineQueriesInCodeblocks: boolean;
+  /** Enable or disable executing DataviewJS queries. */
+  enableDataviewJs: boolean;
+  /** Enable or disable regular inline queries. */
+  enableInlineDataview: boolean;
+  /** Enable or disable executing inline DataviewJS queries. */
+  enableInlineDataviewJs: boolean;
+  /** Enable or disable rendering inline fields prettily in Reading View. */
+  prettyRenderInlineFields: boolean;
+  /** Enable or disable rendering inline fields prettily in Live Preview. */
+  prettyRenderInlineFieldsInLivePreview: boolean;
+  /** The keyword for DataviewJS blocks. */
+  dataviewJsKeyword: string;
+}
+/** Default settings for dataview on install. */
+export declare const DEFAULT_SETTINGS: DataviewSettings;

package/dist/lib/obsidian/@types/Dataview/typings/{obsidian-ex.d.ts → obsidian-ex.d.cts}

@@ -1,5 +1,5 @@
 import type { Plugin } from 'obsidian';
-import type { DataviewApi } from '../api/plugin-api.d.ts';
+import type { DataviewApi } from '../api/plugin-api.d.cjs';
 
 declare module 'obsidian' {
   interface MetadataCache {

package/dist/lib/obsidian/@types/Dataview/typings/obsidian-ex.d.mts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'obsidian';
+import type { DataviewApi } from '../api/plugin-api.d.mjs';
+
+declare module 'obsidian' {
+  interface MetadataCache {
+    trigger(...args: Parameters<MetadataCache['on']>): void;
+    trigger(name: string, ...data: any[]): void;
+  }
+
+  interface Workspace {
+    /** Sent to rendered dataview components to tell them to possibly refresh */
+    on(name: 'dataview:refresh-views', callback: () => void, ctx?: any): EventRef;
+  }
+}
+
+declare global {
+  interface Window {
+    DataviewAPI?: DataviewApi;
+  }
+}
+
+declare module 'obsidian-typings' {
+  interface PluginsPluginsRecord {
+    dataview?: Plugin & {
+      api: DataviewApi;
+    };
+  }
+}

package/dist/lib/obsidian/@types/Dataview/typings/workers.d.mts

@@ -0,0 +1,4 @@
+declare module 'web-worker:*' {
+  const WorkerFactory: new (options: any) => Worker;
+  export default WorkerFactory;
+}

package/dist/lib/obsidian/@types/Dataview/ui/export/{markdown.d.ts → markdown.d.cts}

@@ -1,12 +1,12 @@
-import type { SListItem } from '../../data-model/serialized/markdown.d.ts';
+import type { SListItem } from '../../data-model/serialized/markdown.d.cjs';
 import type {
   Grouping,
   Literal
-} from '../../data-model/value.d.ts';
+} from '../../data-model/value.d.cjs';
 import type {
   ExportSettings,
   QuerySettings
-} from '../../settings.d.ts';
+} from '../../settings.d.cjs';
 /** Render a table of literals to Markdown. */
 export declare function markdownTable(headers: string[], values: Literal[][], settings?: QuerySettings & ExportSettings): string;
 /** Render a list of literal elements to a markdown list. */

package/dist/lib/obsidian/@types/Dataview/ui/export/markdown.d.mts

@@ -0,0 +1,15 @@
+import type { SListItem } from '../../data-model/serialized/markdown.d.mjs';
+import type {
+  Grouping,
+  Literal
+} from '../../data-model/value.d.mjs';
+import type {
+  ExportSettings,
+  QuerySettings
+} from '../../settings.d.mjs';
+/** Render a table of literals to Markdown. */
+export declare function markdownTable(headers: string[], values: Literal[][], settings?: QuerySettings & ExportSettings): string;
+/** Render a list of literal elements to a markdown list. */
+export declare function markdownList(values: Literal[], settings?: QuerySettings & ExportSettings): string;
+/** Render the result of a task query to markdown. */
+export declare function markdownTaskList(tasks: Grouping<SListItem>, settings?: QuerySettings & ExportSettings, depth?: number): string;

package/dist/lib/obsidian/@types/Dataview/ui/{lp-render.d.ts → lp-render.d.cts}

@@ -15,9 +15,9 @@ import type {
   Component,
   TFile
 } from 'obsidian';
-import type { DataviewApi } from '../api/plugin-api.d.ts';
-import type { FullIndex } from '../data-index/index.d.ts';
-import type { DataviewSettings } from '../settings.d.ts';
+import type { DataviewApi } from '../api/plugin-api.d.cjs';
+import type { FullIndex } from '../data-index/index.d.cjs';
+import type { DataviewSettings } from '../settings.d.cjs';
 export declare function selectionAndRangeOverlap(selection: EditorSelection, rangeFrom: number, rangeTo: number): boolean;
 export declare function inlinePlugin(app: App, index: FullIndex, settings: DataviewSettings, api: DataviewApi): ViewPlugin<{
   decorations: DecorationSet;

package/dist/lib/obsidian/@types/Dataview/ui/lp-render.d.mts

@@ -0,0 +1,37 @@
+import type {
+  EditorSelection,
+  Range
+} from '@codemirror/state';
+import type {
+  Decoration,
+  DecorationSet,
+  EditorView,
+  ViewPlugin,
+  ViewUpdate
+} from '@codemirror/view';
+import type { SyntaxNode } from '@lezer/common';
+import type {
+  App,
+  Component,
+  TFile
+} from 'obsidian';
+import type { DataviewApi } from '../api/plugin-api.d.mjs';
+import type { FullIndex } from '../data-index/index.d.mjs';
+import type { DataviewSettings } from '../settings.d.mjs';
+export declare function selectionAndRangeOverlap(selection: EditorSelection, rangeFrom: number, rangeTo: number): boolean;
+export declare function inlinePlugin(app: App, index: FullIndex, settings: DataviewSettings, api: DataviewApi): ViewPlugin<{
+  decorations: DecorationSet;
+  component: Component;
+  update(update: ViewUpdate): void;
+  updateTree(view: EditorView): void;
+  removeDeco(node: SyntaxNode): void;
+  addDeco(node: SyntaxNode, view: EditorView): void;
+  renderNode(view: EditorView, node: SyntaxNode): {
+    render: boolean;
+    isQuery: boolean;
+  };
+  isInlineQuery(view: EditorView, start: number, end: number): boolean;
+  inlineRender(view: EditorView): DecorationSet | undefined;
+  renderWidget(node: SyntaxNode, view: EditorView, currentFile: TFile): Range<Decoration> | undefined;
+  destroy(): void;
+}>;

package/dist/lib/obsidian/@types/Dataview/ui/{markdown.d.ts → markdown.d.cts}

@@ -9,9 +9,9 @@ import type {
   h
 } from 'preact';
 import React from 'preact/compat';
-import type { FullIndex } from '../data-index/index.d.ts';
-import type { Literal } from '../data-model/value.d.ts';
-import type { DataviewSettings } from '../settings.d.ts';
+import type { FullIndex } from '../data-index/index.d.cjs';
+import type { Literal } from '../data-model/value.d.cjs';
+import type { DataviewSettings } from '../settings.d.cjs';
 export type MarkdownProps = {
   contents: string;
   sourcePath: string;

package/dist/lib/obsidian/@types/Dataview/ui/markdown.d.mts

@@ -0,0 +1,86 @@
+/** Provides core preact / rendering utilities for all view types. */
+import type {
+  App,
+  MarkdownRenderChild
+} from 'obsidian';
+import type { Component } from 'obsidian';
+import type {
+  ComponentChildren,
+  h
+} from 'preact';
+import React from 'preact/compat';
+import type { FullIndex } from '../data-index/index.d.mjs';
+import type { Literal } from '../data-model/value.d.mjs';
+import type { DataviewSettings } from '../settings.d.mjs';
+export type MarkdownProps = {
+  contents: string;
+  sourcePath: string;
+};
+export type MarkdownContext = {
+  component: Component;
+};
+/** Context need to create dataviews. */
+export type DataviewInit = {
+  app: App;
+  index: FullIndex;
+  settings: DataviewSettings;
+  container: HTMLElement;
+};
+/** Shared context for dataview views and objects. */
+export type DataviewContexts = DataviewInit & {
+  component: Component;
+};
+export declare const DataviewContext: React.Context<DataviewContexts>;
+/** Hacky preact component which wraps Obsidian's markdown renderer into a neat component. */
+export declare function RawMarkdown({ content, sourcePath, inline, style, cls, onClick }: {
+  content: string;
+  sourcePath: string;
+  inline?: boolean;
+  style?: string;
+  cls?: string;
+  onClick?: (e: preact.JSX.TargetedMouseEvent<HTMLElement>) => void;
+}): h.JSX.Element;
+/** Hacky preact component which wraps Obsidian's markdown renderer into a neat component. */
+export declare const Markdown: typeof RawMarkdown;
+/** Embeds an HTML element in the react DOM. */
+export declare function RawEmbedHtml({ element }: {
+  element: HTMLElement;
+}): h.JSX.Element;
+/** Embeds an HTML element in the react DOM. */
+export declare const EmbedHtml: typeof RawEmbedHtml;
+/** Intelligently render an arbitrary literal value. */
+export declare function RawLit({ value, sourcePath, inline, depth }: {
+  value: Literal | undefined;
+  sourcePath: string;
+  inline?: boolean;
+  depth?: number;
+}): h.JSX.Element;
+/** Intelligently render an arbitrary literal value. */
+export declare const Lit: typeof RawLit;
+/** Render a simple nice looking error box in a code style. */
+export declare function ErrorPre(props: {
+  children: ComponentChildren;
+}, {}: {}): h.JSX.Element;
+/** Render a pretty centered error message in a box. */
+export declare function ErrorMessage({ message }: {
+  message: string;
+}): h.JSX.Element;
+/**
+ * Complex convenience hook which calls `compute` every time the index updates, updating the current state.
+ */
+export declare function useIndexBackedState<T>(
+  container: HTMLElement,
+  app: App,
+  settings: DataviewSettings,
+  index: FullIndex,
+  initial: T,
+  compute: () => Promise<T>
+): T;
+/** A trivial wrapper which allows a react component to live for the duration of a `MarkdownRenderChild`. */
+export declare class ReactRenderer extends MarkdownRenderChild {
+  init: DataviewInit;
+  element: h.JSX.Element;
+  constructor(init: DataviewInit, element: h.JSX.Element);
+  onload(): void;
+  onunload(): void;
+}

package/dist/lib/obsidian/@types/Dataview/ui/{refreshable-view.d.ts → refreshable-view.d.cts}

@@ -2,8 +2,8 @@ import type {
   App,
   MarkdownRenderChild
 } from 'obsidian';
-import type { FullIndex } from '../data-index/index.d.ts';
-import type { DataviewSettings } from '../settings.d.ts';
+import type { FullIndex } from '../data-index/index.d.cjs';
+import type { DataviewSettings } from '../settings.d.cjs';
 /** Generic code for embedded Dataviews. */
 export declare abstract class DataviewRefreshableRenderer extends MarkdownRenderChild {
   container: HTMLElement;

package/dist/lib/obsidian/@types/Dataview/ui/refreshable-view.d.mts

@@ -0,0 +1,18 @@
+import type {
+  App,
+  MarkdownRenderChild
+} from 'obsidian';
+import type { FullIndex } from '../data-index/index.d.mjs';
+import type { DataviewSettings } from '../settings.d.mjs';
+/** Generic code for embedded Dataviews. */
+export declare abstract class DataviewRefreshableRenderer extends MarkdownRenderChild {
+  container: HTMLElement;
+  index: FullIndex;
+  app: App;
+  settings: DataviewSettings;
+  private lastReload;
+  constructor(container: HTMLElement, index: FullIndex, app: App, settings: DataviewSettings);
+  abstract render(): Promise<void>;
+  onload(): void;
+  maybeRefresh: () => void;
+}

package/dist/lib/obsidian/@types/Dataview/ui/{render.d.ts → render.d.cts}

@@ -2,8 +2,8 @@ import type {
   App,
   Component
 } from 'obsidian';
-import type { Literal } from '../data-model/value.d.ts';
-import type { QuerySettings } from '../settings.d.ts';
+import type { Literal } from '../data-model/value.d.cjs';
+import type { QuerySettings } from '../settings.d.cjs';
 /** Render simple fields compactly, removing wrapping content like paragraph and span. */
 export declare function renderCompactMarkdown(
   app: App,

package/dist/lib/obsidian/@types/Dataview/ui/render.d.mts

@@ -0,0 +1,33 @@
+import type {
+  App,
+  Component
+} from 'obsidian';
+import type { Literal } from '../data-model/value.d.mjs';
+import type { QuerySettings } from '../settings.d.mjs';
+/** Render simple fields compactly, removing wrapping content like paragraph and span. */
+export declare function renderCompactMarkdown(
+  app: App,
+  markdown: string,
+  container: HTMLElement,
+  sourcePath: string,
+  component: Component,
+  isInlineFieldLivePreview?: boolean
+): Promise<void>;
+/** Render a pre block with an error in it; returns the element to allow for dynamic updating. */
+export declare function renderErrorPre(container: HTMLElement, error: string): HTMLElement;
+/** Render a static codeblock. */
+export declare function renderCodeBlock(container: HTMLElement, source: string, language?: string): HTMLElement;
+export type ValueRenderContext = 'root' | 'list';
+/** Prettily render a value into a container with the given settings. */
+export declare function renderValue(
+  app: App,
+  field: Literal,
+  container: HTMLElement,
+  originFile: string,
+  component: Component,
+  settings: QuerySettings,
+  expandList?: boolean,
+  context?: ValueRenderContext,
+  depth?: number,
+  isInlineFieldLivePreview?: boolean
+): Promise<void>;

package/dist/lib/obsidian/@types/Dataview/ui/views/{calendar-view.d.ts → calendar-view.d.cts}

@@ -1,8 +1,8 @@
 import type { App } from 'obsidian';
-import type { FullIndex } from '../../data-index/index.d.ts';
-import type { Query } from '../../query/query.d.ts';
-import type { DataviewSettings } from '../../settings.d.ts';
-import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.ts';
+import type { FullIndex } from '../../data-index/index.d.cjs';
+import type { Query } from '../../query/query.d.cjs';
+import type { DataviewSettings } from '../../settings.d.cjs';
+import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.cjs';
 export declare class DataviewCalendarRenderer extends DataviewRefreshableRenderer {
   query: Query;
   container: HTMLElement;

package/dist/lib/obsidian/@types/Dataview/ui/views/calendar-view.d.mts

@@ -0,0 +1,17 @@
+import type { App } from 'obsidian';
+import type { FullIndex } from '../../data-index/index.d.mjs';
+import type { Query } from '../../query/query.d.mjs';
+import type { DataviewSettings } from '../../settings.d.mjs';
+import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.mjs';
+export declare class DataviewCalendarRenderer extends DataviewRefreshableRenderer {
+  query: Query;
+  container: HTMLElement;
+  index: FullIndex;
+  origin: string;
+  settings: DataviewSettings;
+  app: App;
+  private calendar;
+  constructor(query: Query, container: HTMLElement, index: FullIndex, origin: string, settings: DataviewSettings, app: App);
+  render(): Promise<void>;
+  onClose(): Promise<void>;
+}

package/dist/lib/obsidian/@types/Dataview/ui/views/{inline-field-live-preview.d.ts → inline-field-live-preview.d.cts}

@@ -14,8 +14,8 @@ import type {
   Component,
   TFile
 } from 'obsidian';
-import type { InlineField } from '../../data-import/inline-field.d.ts';
-import type { DataviewSettings } from '../../settings.d.ts';
+import type { InlineField } from '../../data-import/inline-field.d.cjs';
+import type { DataviewSettings } from '../../settings.d.cjs';
 declare class InlineFieldValue extends RangeValue {
   field: InlineField;
   constructor(field: InlineField);

package/dist/lib/obsidian/@types/Dataview/ui/views/inline-field-live-preview.d.mts

@@ -0,0 +1,42 @@
+import type {
+  RangeSet,
+  RangeValue,
+  StateField
+} from '@codemirror/state';
+import type {
+  DecorationSet,
+  EditorView,
+  ViewPlugin,
+  ViewUpdate
+} from '@codemirror/view';
+import type {
+  App,
+  Component,
+  TFile
+} from 'obsidian';
+import type { InlineField } from '../../data-import/inline-field.d.mjs';
+import type { DataviewSettings } from '../../settings.d.mjs';
+declare class InlineFieldValue extends RangeValue {
+  field: InlineField;
+  constructor(field: InlineField);
+  eq(other: InlineFieldValue): boolean;
+}
+/** A state field that stores the inline fields and their positions as a range set. */
+export declare const inlineFieldsField: StateField<RangeSet<InlineFieldValue>>;
+/** Create a view plugin that renders inline fields in live preview just as in the reading view. */
+export declare const replaceInlineFieldsInLivePreview: (app: App, settings: DataviewSettings) => ViewPlugin<{
+  decorations: DecorationSet;
+  component: Component;
+  destroy(): void;
+  buildDecorations(view: EditorView): DecorationSet;
+  update(update: ViewUpdate): void;
+  updateDecorations(view: EditorView): void;
+  removeDeco(start: number, end: number): void;
+  addDeco(start: number, end: number, field: InlineField, file: TFile, view: EditorView): void;
+}>;
+/**
+ * A state effect that represents the workspace's layout change.
+ * Mainly intended to detect when the user switches between live preview and source mode.
+ */
+export declare const workspaceLayoutChangeEffect: import('@codemirror/state').StateEffectType<null>;
+export {};

package/dist/lib/obsidian/@types/Dataview/ui/views/{inline-view.d.ts → inline-view.d.cts}

@@ -1,8 +1,8 @@
 import type { App } from 'obsidian';
-import type { FullIndex } from '../../data-index/index.d.ts';
-import type { Field } from '../../expression/field.d.ts';
-import type { DataviewSettings } from '../../settings.d.ts';
-import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.ts';
+import type { FullIndex } from '../../data-index/index.d.cjs';
+import type { Field } from '../../expression/field.d.cjs';
+import type { DataviewSettings } from '../../settings.d.cjs';
+import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.cjs';
 /** Refreshable renderer which renders inline instead of in a div. */
 export declare class DataviewInlineRenderer extends DataviewRefreshableRenderer {
   field: Field;

package/dist/lib/obsidian/@types/Dataview/ui/views/inline-view.d.mts

@@ -0,0 +1,28 @@
+import type { App } from 'obsidian';
+import type { FullIndex } from '../../data-index/index.d.mjs';
+import type { Field } from '../../expression/field.d.mjs';
+import type { DataviewSettings } from '../../settings.d.mjs';
+import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.mjs';
+/** Refreshable renderer which renders inline instead of in a div. */
+export declare class DataviewInlineRenderer extends DataviewRefreshableRenderer {
+  field: Field;
+  fieldText: string;
+  container: HTMLElement;
+  target: HTMLElement;
+  index: FullIndex;
+  origin: string;
+  settings: DataviewSettings;
+  app: App;
+  errorbox?: HTMLElement;
+  constructor(
+    field: Field,
+    fieldText: string,
+    container: HTMLElement,
+    target: HTMLElement,
+    index: FullIndex,
+    origin: string,
+    settings: DataviewSettings,
+    app: App
+  );
+  render(): Promise<void>;
+}

package/dist/lib/obsidian/@types/Dataview/ui/views/{js-view.d.ts → js-view.d.cts}

@@ -1,5 +1,5 @@
-import type { DataviewApi } from '../../api/plugin-api.d.ts';
-import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.ts';
+import type { DataviewApi } from '../../api/plugin-api.d.cjs';
+import type { DataviewRefreshableRenderer } from '../../ui/refreshable-view.d.cjs';
 export declare class DataviewJSRenderer extends DataviewRefreshableRenderer {
   api: DataviewApi;
   script: string;