obsidian-dev-utils 19.0.0 → 19.1.0

package/dist/lib/obsidian/@types/Dataview/api/plugin-api.d.mts

@@ -1,209 +1 @@
-/** The general, externally accessible plugin API (available at `app.plugins.plugins.dataview.api` or as global `DataviewAPI`). */
-import type { CompareOperator } from 'compare-versions';
-import type {
-  DateTime,
-  Duration
-} from 'luxon';
-import * as Luxon from 'luxon';
-import type {
-  App,
-  Component,
-  MarkdownPostProcessorContext
-} from 'obsidian';
-import type { Result } from '../api/result.d.mjs';
-import type { FullIndex } from '../data-index/index.d.mjs';
-import type { SListItem } from '../data-model/serialized/markdown.d.mjs';
-import type {
-  DataObject,
-  Grouping,
-  Link,
-  Literal,
-  Values,
-  Widgets
-} from '../data-model/value.d.mjs';
-import type { Context } from '../expression/context.d.mjs';
-import type { BoundFunctionImpl } from '../expression/functions.d.mjs';
-import type { IdentifierMeaning } from '../query/engine.d.mjs';
-import type { Query } from '../query/query.d.mjs';
-import type {
-  DataviewSettings,
-  ExportSettings
-} from '../settings.d.mjs';
-import type { DataArray } from './data-array.d.mjs';
-/** Asynchronous API calls related to file / system IO. */
-export declare class DataviewIOApi {
-  api: DataviewApi;
-  constructor(api: DataviewApi);
-  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
-  csv(path: Link | string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
-  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
-  load(path: Link | string, originFile?: string): Promise<string | undefined>;
-  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
-  normalize(path: Link | string, originFile?: string): string;
-}
-/** Global API for accessing the Dataview API, executing dataview queries, and  */
-export declare class DataviewApi {
-  app: App;
-  index: FullIndex;
-  settings: DataviewSettings;
-  private verNum;
-  /** Evaluation context which expressions can be evaluated in. */
-  evaluationContext: Context;
-  /** IO API which supports asynchronous loading of data directly. */
-  io: DataviewIOApi;
-  /** Dataview functions which can be called from DataviewJS. */
-  func: Record<string, BoundFunctionImpl>;
-  /** Value utility functions for comparisons and type-checking. */
-  value: typeof Values;
-  /** Widget utility functions for creating built-in widgets. */
-  widget: typeof Widgets;
-  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
-  luxon: typeof Luxon;
-  constructor(app: App, index: FullIndex, settings: DataviewSettings, verNum: string);
-  /** Utilities to check the current Dataview version and compare it to SemVer version ranges. */
-  version: {
-    current: string;
-    compare: (op: CompareOperator, ver: string) => boolean;
-    satisfies: (range: string) => boolean;
-  };
-  /** Return an array of paths (as strings) corresponding to pages which match the query. */
-  pagePaths(query?: string, originFile?: string): DataArray<string>;
-  /** Map a page path to the actual data contained within that page. */
-  page(path: string | Link, originFile?: string): Record<string, Literal> | undefined;
-  /** Return an array of page objects corresponding to pages which match the source query. */
-  pages(query?: string, originFile?: string): DataArray<Record<string, Literal>>;
-  /** Remaps important metadata to add data arrays.  */
-  private _addDataArrays;
-  /**
-   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
-   * it is returned unchanged.
-   */
-  array(raw: unknown): DataArray<any>;
-  /** Return true if the given value is a javascript array OR a dataview data array. */
-  isArray(raw: unknown): raw is DataArray<any> | Array<any>;
-  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
-  isDataArray(raw: unknown): raw is DataArray<any>;
-  /** Create a dataview file link to the given path. */
-  fileLink(path: string, embed?: boolean, display?: string): Link;
-  /** Create a dataview section link to the given path. */
-  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
-  /** Create a dataview block link to the given path. */
-  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
-  /** Attempt to extract a date from a string, link or date. */
-  date(pathlike: string | Link | DateTime): DateTime | null;
-  /** Attempt to extract a duration from a string or duration. */
-  duration(str: string | Duration): Duration | null;
-  /** Parse a raw textual value into a complex Dataview type, if possible. */
-  parse(value: string): Literal;
-  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
-  literal(value: any): Literal;
-  /** Deep clone the given literal, returning a new literal which is independent of the original. */
-  clone(value: Literal): Literal;
-  /**
-   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
-   * a < b, 0 if a = b, and a positive value if a > b.
-   */
-  compare(a: any, b: any): number;
-  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
-  equal(a: any, b: any): boolean;
-  /**
-   * Execute an arbitrary Dataview query, returning a query result which:
-   *
-   * 1. Indicates the type of query,
-   * 2. Includes the raw AST of the parsed query.
-   * 3. Includes the output in the form relevant to that query type.
-   *
-   * List queries will return a list of objects ({ id, value }); table queries return a header array
-   * and a 2D array of values; and task arrays return a Grouping<Task> type which allows for recursive
-   * task nesting.
-   */
-  query(source: string | Query, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
-  /** Error-throwing version of {@link query}. */
-  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
-  /** Execute an arbitrary dataview query, returning the results in well-formatted markdown. */
-  queryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<Result<string, string>>;
-  /** Error-throwing version of {@link queryMarkdown}. */
-  tryQueryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<string>;
-  /**
-   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
-   * This takes an optional second argument which provides definitions for variables, such as:
-   *
-   * ```
-   * dv.evaluate("x + 6", { x: 2 }) = 8
-   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
-   * ```
-   *
-   * This method returns a Result type instead of throwing an error; you can check the result of the
-   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
-   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
-   */
-  evaluate(expression: string, context?: DataObject, originFile?: string): Result<Literal, string>;
-  /** Error-throwing version of `dv.evaluate`. */
-  tryEvaluate(expression: string, context?: DataObject, originFile?: string): Literal;
-  /** Evaluate an expression in the context of the given file. */
-  evaluateInline(expression: string, origin: string): Result<Literal, string>;
-  /**
-   * Execute the given query, rendering results into the given container using the components lifecycle.
-   * Your component should be a *real* component which calls onload() on it's child components at some point,
-   * or a MarkdownPostProcessorContext!
-   *
-   * Note that views made in this way are live updating and will automatically clean themselves up when
-   * the component is unloaded or the container is removed.
-   */
-  execute(source: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
-  /**
-   * Execute the given DataviewJS query, rendering results into the given container using the components lifecycle.
-   * See {@link execute} for general rendering semantics.
-   */
-  executeJs(code: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
-  /** Render a dataview list of the given values. */
-  list(values: any[] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
-  /** Render a dataview table with the given headers, and the 2D array of values. */
-  table(headers: string[], values: any[][] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
-  /** Render a dataview task view with the given tasks. */
-  taskList(tasks: Grouping<SListItem>, groupByFile: boolean | undefined, container: HTMLElement, component: Component, filePath?: string): Promise<void>;
-  /** Render an arbitrary value into a container. */
-  renderValue(value: any, container: HTMLElement, component: Component, filePath: string, inline?: boolean): Promise<void>;
-  /** Render data to a markdown table. */
-  markdownTable(headers: string[] | undefined, values: any[][] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
-  /** Render data to a markdown list. */
-  markdownList(values: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
-  /** Render tasks or list items to a markdown task list. */
-  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
-}
-/** The result of executing a table query. */
-export type TableResult = {
-  type: 'table';
-  headers: string[];
-  values: Literal[][];
-  idMeaning: IdentifierMeaning;
-};
-/** The result of executing a list query. */
-export type ListResult = {
-  type: 'list';
-  values: Literal[];
-  primaryMeaning: IdentifierMeaning;
-};
-/** The result of executing a task query. */
-export type TaskResult = {
-  type: 'task';
-  values: Grouping<SListItem>;
-};
-/** The result of executing a calendar query. */
-export type CalendarResult = {
-  type: 'calendar';
-  values: {
-    date: DateTime;
-    link: Link;
-    value?: Literal[];
-  }[];
-};
-/** The result of executing a query of some sort. */
-export type QueryResult = TableResult | ListResult | TaskResult | CalendarResult;
-/** Settings when querying the dataview API. */
-export type QueryApiSettings = {
-  /** If present, then this forces queries to include/exclude the implicit id field (such as with `WITHOUT ID`). */
-  forceId?: boolean;
-};
-/** Determines if source-path has a `?no-dataview` annotation that disables dataview. */
-export declare function isDataviewDisabled(sourcePath: string): boolean;
+export * from './plugin-api.cjs';

package/dist/lib/obsidian/@types/Dataview/api/result.d.mts

@@ -1,38 +1 @@
-/** Functional return type for error handling. */
-export declare class Success<T, E> {
-  value: T;
-  successful: true;
-  constructor(value: T);
-  map<U>(f: (a: T) => U): Result<U, E>;
-  flatMap<U>(f: (a: T) => Result<U, E>): Result<U, E>;
-  mapErr<U>(f: (e: E) => U): Result<T, U>;
-  bimap<T2, E2>(succ: (a: T) => T2, _fail: (b: E) => E2): Result<T2, E2>;
-  orElse(_value: T): T;
-  cast<U>(): Result<U, E>;
-  orElseThrow(_message?: (e: E) => string): T;
-}
-/** Functional return type for error handling. */
-export declare class Failure<T, E> {
-  error: E;
-  successful: false;
-  constructor(error: E);
-  map<U>(_f: (a: T) => U): Result<U, E>;
-  flatMap<U>(_f: (a: T) => Result<U, E>): Result<U, E>;
-  mapErr<U>(f: (e: E) => U): Result<T, U>;
-  bimap<T2, E2>(_succ: (a: T) => T2, fail: (b: E) => E2): Result<T2, E2>;
-  orElse(value: T): T;
-  cast<U>(): Result<U, E>;
-  orElseThrow(message?: (e: E) => string): T;
-}
-export type Result<T, E> = Success<T, E> | Failure<T, E>;
-/** Monadic 'Result' type which encapsulates whether a procedure succeeded or failed, as well as it's return value. */
-export declare namespace Result {
-  /** Construct a new success result wrapping the given value. */
-  function success<T, E>(value: T): Result<T, E>;
-  /** Construct a new failure value wrapping the given error. */
-  function failure<T, E>(error: E): Result<T, E>;
-  /** Join two results with a bi-function and return a new result. */
-  function flatMap2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => Result<O, E>): Result<O, E>;
-  /** Join two results with a bi-function and return a new result. */
-  function map2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => O): Result<O, E>;
-}
+export * from './result.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/common.d.mts

@@ -1,3 +1 @@
-/** Common utilities for extracting tags, links, and other business from metadata. */
-/** Extract all tags from the given source string. */
-export declare function extractTags(source: string): Set<string>;
+export * from './common.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/csv.d.mts

@@ -1,3 +1 @@
-import type { DataObject } from '../data-model/value.d.mjs';
-/** Parse a CSV file into a collection of data rows. */
-export declare function parseCsv(content: string): DataObject[];
+export * from './csv.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/inline-field.d.mts

@@ -1,42 +1 @@
-/** Parse inline fields and other embedded metadata in a line. */
-import type { Literal } from '../data-model/value.d.mjs';
-/** A parsed inline field. */
-export interface InlineField {
-  /** The raw parsed key. */
-  key: string;
-  /** The raw value of the field. */
-  value: string;
-  /** The start column of the field. */
-  start: number;
-  /** The start column of the *value* for the field. */
-  startValue: number;
-  /** The end column of the field. */
-  end: number;
-  /** If this inline field was defined via a wrapping ('[' or '('), then the wrapping that was used. */
-  wrapping?: string;
-}
-/** The wrapper characters that can be used to define an inline field. */
-export declare const INLINE_FIELD_WRAPPERS: Readonly<Record<string, string>>;
-/** Parse a textual inline field value into something we can work with. */
-export declare function parseInlineValue(value: string): Literal;
-/** Extracts inline fields of the form '[key:: value]' from a line of text. This is done in a relatively
- * "robust" way to avoid failing due to bad nesting or other interfering Markdown symbols:
- *
- * - Look for any wrappers ('[' and '(') in the line, trying to parse whatever comes after it as an inline key::.
- * - If successful, scan until you find a matching end bracket, and parse whatever remains as an inline value.
- */
-export declare function extractInlineFields(line: string, includeTaskFields?: boolean): InlineField[];
-/** Attempt to extract a full-line field (Key:: Value consuming the entire content line). */
-export declare function extractFullLineField(text: string): InlineField | undefined;
-export declare const CREATED_DATE_REGEX: RegExp;
-export declare const DUE_DATE_REGEX: RegExp;
-export declare const DONE_DATE_REGEX: RegExp;
-export declare const SCHEDULED_DATE_REGEX: RegExp;
-export declare const START_DATE_REGEX: RegExp;
-export declare const EMOJI_REGEXES: {
-  regex: RegExp;
-  key: string;
-}[];
-/** Sets or replaces the value of an inline field; if the value is 'undefined', deletes the key. */
-export declare function setInlineField(source: string, key: string, value?: string): string;
-export declare function setEmojiShorthandCompletionField(source: string, value?: string): string;
+export * from './inline-field.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/markdown-file.d.mts

@@ -1,52 +1 @@
-/** Importer for markdown documents. */
-import type {
-  CachedMetadata,
-  FileStats,
-  FrontMatterCache,
-  HeadingCache
-} from 'obsidian';
-import type { InlineField } from '../data-import/inline-field.d.mjs';
-import type {
-  ListItem,
-  PageMetadata
-} from '../data-model/markdown.d.mjs';
-import type {
-  Link,
-  Literal
-} from '../data-model/value.d.mjs';
-/** Extract markdown metadata from the given Obsidian markdown file. */
-export declare function parsePage(path: string, contents: string, stat: FileStats, metadata: CachedMetadata): PageMetadata;
-/** Extract tags intelligently from frontmatter. Handles arrays, numbers, and strings. */
-export declare function extractTags(metadata: FrontMatterCache): string[];
-/** Extract aliases intelligently from frontmatter. Handles arrays, numbers, and strings.  */
-export declare function extractAliases(metadata: FrontMatterCache): string[];
-/** Split a frontmatter list into separate elements; handles actual lists, comma separated lists, and single elements. */
-export declare function splitFrontmatterTagOrAlias(data: any, on: RegExp): string[];
-/** Parse raw (newline-delimited) markdown, returning inline fields, list items, and other metadata. */
-export declare function parseMarkdown(path: string, contents: string[], metadata: CachedMetadata, linksByLine: Record<number, Link[]>): {
-  fields: Map<string, Literal[]>;
-  lists: ListItem[];
-};
-export declare const LIST_ITEM_REGEX: RegExp;
-/**
- * Parse list items from the page + metadata. This requires some additional parsing above whatever Obsidian provides,
- * since Obsidian only gives line numbers.
- */
-export declare function parseLists(
-  path: string,
-  content: string[],
-  metadata: CachedMetadata,
-  linksByLine: Record<number, Link[]>
-): [ListItem[], Map<string, Literal[]>];
-/** Recursively convert frontmatter into fields. We have to dance around YAML structure. */
-export declare function parseFrontmatter(value: any): Literal;
-/** Add a parsed inline field to the output map. */
-export declare function addRawInlineField(field: InlineField, output: Map<string, Literal[]>): void;
-/** Add a raw inline field to an output map, canonicalizing as needed. */
-export declare function addInlineField(key: string, value: Literal, output: Map<string, Literal[]>): void;
-/** Given a raw list of inline field values, add normalized keys and squash them. */
-export declare function finalizeInlineFields(fields: Map<string, Literal[]>): Map<string, Literal>;
-/** Copy all fields of 'source' into 'target'. */
-export declare function mergeFieldGroups(target: Map<string, Literal[]>, source: Map<string, Literal[]>): void;
-/** Find the header that is most immediately above the given line number. */
-export declare function findPreviousHeader(line: number, headers: HeadingCache[]): string | undefined;
+export * from './markdown-file.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/persister.d.mts

@@ -1,32 +1 @@
-type LocalForage = typeof import('localforage');
-
-import type { PageMetadata } from '../data-model/markdown.d.mjs';
-/** A piece of data that has been cached for a specific version and time. */
-export interface Cached<T> {
-  /** The version of Dataview that the data was written to cache with. */
-  version: string;
-  /** The time that the data was written to cache. */
-  time: number;
-  /** The data that was cached. */
-  data: T;
-}
-/** Simpler wrapper for a file-backed cache for arbitrary metadata. */
-export declare class LocalStorageCache {
-  appId: string;
-  version: string;
-  persister: LocalForage;
-  constructor(appId: string, version: string);
-  /** Drop the entire cache instance and re-create a new fresh instance. */
-  recreate(): Promise<void>;
-  /** Load file metadata by path. */
-  loadFile(path: string): Promise<Cached<Partial<PageMetadata>> | null | undefined>;
-  /** Store file metadata by path. */
-  storeFile(path: string, data: Partial<PageMetadata>): Promise<void>;
-  /** Drop old file keys that no longer exist. */
-  synchronize(existing: string[] | Set<string>): Promise<Set<string>>;
-  /** Obtain a list of all metadata keys. */
-  allKeys(): Promise<string[]>;
-  /** Obtain a list of all persisted files. */
-  allFiles(): Promise<string[]>;
-  fileKey(path: string): string;
-}
+export * from './persister.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/web-worker/import-entry.d.mts

@@ -1 +1 @@
-export {};
+export * from './import-entry.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/web-worker/import-impl.d.mts

@@ -1,6 +1 @@
-import type {
-  CachedMetadata,
-  FileStats
-} from 'obsidian';
-import type { PageMetadata } from '../../data-model/markdown.d.mjs';
-export declare function runImport(path: string, contents: string, stats: FileStats, metadata: CachedMetadata): Partial<PageMetadata>;
+export * from './import-impl.cjs';

package/dist/lib/obsidian/@types/Dataview/data-import/web-worker/import-manager.d.mts

@@ -1,37 +1 @@
-/** Controls and creates Dataview file importers, allowing for asynchronous loading and parsing of files. */
-import type {
-  Component,
-  MetadataCache,
-  TFile,
-  Vault
-} from 'obsidian';
-/** Callback when a file is resolved. */
-type FileCallback = (p: any) => void;
-/** Multi-threaded file parser which debounces rapid file requests automatically. */
-export declare class FileImporter extends Component {
-  numWorkers: number;
-  vault: Vault;
-  metadataCache: MetadataCache;
-  workers: Worker[];
-  /** Tracks which workers are actively parsing a file, to make sure we properly delegate results. */
-  busy: boolean[];
-  /** List of files which have been queued for a reload. */
-  reloadQueue: TFile[];
-  /** Fast-access set which holds the list of files queued to be reloaded; used for debouncing. */
-  reloadSet: Set<string>;
-  /** Paths -> promises for file reloads which have not yet been queued. */
-  callbacks: Map<string, [FileCallback, FileCallback][]>;
-  constructor(numWorkers: number, vault: Vault, metadataCache: MetadataCache);
-  /**
-   * Queue the given file for reloading. Multiple reload requests for the same file in a short time period will be de-bounced
-   * and all be resolved by a single actual file reload.
-   */
-  reload<T>(file: TFile): Promise<T>;
-  /** Finish the parsing of a file, potentially queueing a new file. */
-  private finish;
-  /** Send a new task to the given worker ID. */
-  private send;
-  /** Find the next available, non-busy worker; return undefined if all workers are busy. */
-  private nextAvailableWorker;
-}
-export {};
+export * from './import-manager.cjs';

package/dist/lib/obsidian/@types/Dataview/data-index/index.d.mts

@@ -1,186 +1 @@
-/** Stores various indices on all files in the vault to make dataview generation fast. */
-import type { DateTime } from 'luxon';
-import type {
-  App,
-  Component,
-  MetadataCache,
-  TAbstractFile,
-  TFile,
-  Vault
-} from 'obsidian';
-import type { Result } from '../api/result.d.mjs';
-import type { LocalStorageCache } from '../data-import/persister.d.mjs';
-import type { FileImporter } from '../data-import/web-worker/import-manager.d.mjs';
-import type { PageMetadata } from '../data-model/markdown.d.mjs';
-import type { DataObject } from '../data-model/value.d.mjs';
-/** Aggregate index which has several sub-indices and will initialize all of them. */
-export declare class FullIndex extends Component {
-  app: App;
-  indexVersion: string;
-  onChange: () => void;
-  /** Generate a full index from the given vault. */
-  static create(app: App, indexVersion: string, onChange: () => void): FullIndex;
-  /** Whether all files in the vault have been indexed at least once. */
-  initialized: boolean;
-  /** I/O access to the Obsidian vault contents. */
-  vault: Vault;
-  /** Access to in-memory metadata, useful for parsing and metadata lookups. */
-  metadataCache: MetadataCache;
-  /** Persistent IndexedDB backing store, used for faster startup. */
-  persister: LocalStorageCache;
-  pages: Map<string, PageMetadata>;
-  /** Map files -> tags in that file, and tags -> files. This version includes subtags. */
-  tags: ValueCaseInsensitiveIndexMap;
-  /** Map files -> exact tags in that file, and tags -> files. This version does not automatically add subtags. */
-  etags: ValueCaseInsensitiveIndexMap;
-  /** Map files -> linked files in that file, and linked file -> files that link to it. */
-  links: IndexMap;
-  /** Search files by path prefix. */
-  prefix: PrefixIndex;
-  /** Allows for efficient lookups of whether a file is starred or not. */
-  starred: StarredCache;
-  /** Caches data in CSV files. */
-  csv: CsvCache;
-  /**
-   * The current "revision" of the index, which monotonically increases for every index change. Use this to determine
-   * if you are up to date.
-   */
-  revision: number;
-  /** Asynchronously parses files in the background using web workers. */
-  importer: FileImporter;
-  /** Construct a new index using the app data and a current data version. */
-  private constructor();
-  /** Trigger a metadata event on the metadata cache. */
-  private trigger;
-  /** "Touch" the index, incrementing the revision number and causing downstream views to reload. */
-  touch(): void;
-  /** Runs through the whole vault to set up initial file metadata. */
-  initialize(): void;
-  /** Drops the local storage cache and re-indexes all files; this should generally be used if you expect cache issues. */
-  reinitialize(): Promise<void>;
-  /** Internal asynchronous initializer. */
-  private _initialize;
-  rename(file: TAbstractFile, oldPath: string): void;
-  /** Queue a file for reloading; this is done asynchronously in the background and may take a few seconds. */
-  reload(file: TFile): Promise<{
-    cached: boolean;
-    skipped: boolean;
-  }>;
-  /** Import a file directly from disk, skipping the cache. */
-  private import;
-  /** Finish the reloading of file metadata by adding it to in memory indexes. */
-  private finish;
-}
-/** Indexes files by their full prefix - essentially a simple prefix tree. */
-export declare class PrefixIndex extends Component {
-  vault: Vault;
-  updateRevision: () => void;
-  static create(vault: Vault, updateRevision: () => void): PrefixIndex;
-  constructor(vault: Vault, updateRevision: () => void);
-  private walk;
-  /** Get the list of all files under the given path. */
-  get(prefix: string, filter?: (path: string) => boolean): Set<string>;
-  /** Determines if the given path exists in the prefix index. */
-  pathExists(path: string): boolean;
-  /** Determines if the given prefix exists in the prefix index. */
-  nodeExists(prefix: string): boolean;
-  /**
-   * Use the in-memory prefix index to convert a relative path to an absolute one.
-   */
-  resolveRelative(path: string, origin?: string): string;
-}
-/** Simple path filters which filter file types. */
-export declare namespace PathFilters {
-  function csv(path: string): boolean;
-  function markdown(path: string): boolean;
-}
-/**
- * Caches in-use CSVs to make high-frequency reloads (such as actively looking at a document
- * that uses CSV) fast.
- */
-export declare class CsvCache extends Component {
-  vault: Vault;
-  static CACHE_EXPIRY_SECONDS: number;
-  cache: Map<string, {
-    data: DataObject[];
-    loadTime: DateTime;
-  }>;
-  cacheClearInterval: number;
-  constructor(vault: Vault);
-  /** Load a CSV file from the cache, doing a fresh load if it has not been loaded. */
-  get(path: string): Promise<Result<DataObject[], string>>;
-  /** Do the actual raw loading of a CSV path (which is either local or an HTTP request). */
-  private loadInternal;
-  /** Clear old entries in the cache (as measured by insertion time). */
-  private clearOldEntries;
-}
-export type StarredEntry = {
-  type: 'group';
-  items: StarredEntry[];
-  title: string;
-} | {
-  type: 'file';
-  path: string;
-  title: string;
-} | {
-  type: 'folder';
-} | {
-  type: 'query';
-};
-/** Optional connector to the Obsidian 'Starred' plugin which allows for efficiently querying if a file is starred or not. */
-export declare class StarredCache extends Component {
-  app: App;
-  onUpdate: () => void;
-  /** Initial delay before checking the cache; we need to wait for it to asynchronously load the initial stars. */
-  static INITIAL_DELAY: number;
-  /** How frequently to check for star updates. */
-  static REFRESH_INTERVAL: number;
-  /** Set of all starred file paths. */
-  private stars;
-  constructor(app: App, onUpdate: () => void);
-  /** Determines if the given path is starred. */
-  starred(path: string): boolean;
-  private reload;
-  /** Fetch all starred files from the stars plugin, if present. */
-  private static fetch;
-}
-/** A generic index which indexes variables of the form key -> value[], allowing both forward and reverse lookups. */
-export declare class IndexMap {
-  /** Maps key -> values for that key. */
-  map: Map<string, Set<string>>;
-  /** Cached inverse map; maps value -> keys that reference that value. */
-  invMap: Map<string, Set<string>>;
-  /** Create a new, empty index map. */
-  constructor();
-  /** Returns all values for the given key. */
-  get(key: string): Set<string>;
-  /** Returns all keys that reference the given key. Mutating the returned set is not allowed. */
-  getInverse(value: string): Readonly<Set<string>>;
-  /** Sets the key to the given values; this will delete the old mapping for the key if one was present. */
-  set(key: string, values: Set<string>): this;
-  /** Clears all values for the given key so they can be re-added. */
-  delete(key: string): boolean;
-  /** Rename all references to the given key to a new value. */
-  rename(oldKey: string, newKey: string): boolean;
-  /** Clear the entire index. */
-  clear(): void;
-  static EMPTY_SET: Readonly<Set<string>>;
-}
-/** Index map wrapper which is case-insensitive in the key. */
-export declare class ValueCaseInsensitiveIndexMap {
-  delegate: IndexMap;
-  /** Create a new, empty case insensitive index map. */
-  constructor(delegate?: IndexMap);
-  /** Returns all values for the given key. */
-  get(key: string): Set<string>;
-  /** Returns all keys that reference the given value. Mutating the returned set is not allowed. */
-  getInverse(value: string): Readonly<Set<string>>;
-  /** Sets the key to the given values; this will delete the old mapping for the key if one was present. */
-  set(key: string, values: Set<string>): this;
-  /** Clears all values for the given key so they can be re-added. */
-  delete(key: string): boolean;
-  /** Rename all references to the given key to a new value. */
-  rename(oldKey: string, newKey: string): boolean;
-  /** Clear the entire index. */
-  clear(): void;
-}
+export * from './index.cjs';

package/dist/lib/obsidian/@types/Dataview/data-index/resolver.d.mts

@@ -1,23 +1 @@
-/** Collect data matching a source query. */
-import type { Result } from '../api/result.d.mjs';
-import type { FullIndex } from '../data-index/index.d.mjs';
-import type {
-  DataObject,
-  Literal
-} from '../data-model/value.d.mjs';
-import type { Source } from './source.d.mjs';
-/** A data row which has an ID and associated data (like page link / page data). */
-export type Datarow<T> = {
-  id: Literal;
-  data: T;
-};
-/** Find source paths which match the given source. */
-export declare function matchingSourcePaths(source: Source, index: FullIndex, originFile?: string): Result<Set<string>, string>;
-/** Convert a path to the data for that path; usually markdown pages, but could also be other file types (like CSV).  */
-export declare function resolvePathData(path: string, index: FullIndex): Promise<Result<Datarow<DataObject>[], string>>;
-/** Convert a CSV path to the data in the CSV (in dataview format). */
-export declare function resolveCsvData(path: string, index: FullIndex): Promise<Result<Datarow<DataObject>[], string>>;
-/** Convert a path pointing to a markdown page, into the associated metadata. */
-export declare function resolveMarkdownData(path: string, index: FullIndex): Result<Datarow<DataObject>[], string>;
-/** Resolve a source to the collection of data rows that it matches. */
-export declare function resolveSource(source: Source, index: FullIndex, originFile?: string): Promise<Result<Datarow<DataObject>[], string>>;
+export * from './resolver.cjs';