@cspell/cspell-types 6.19.2 → 6.20.1

package/dist/cjs/suggestionCostsDef.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A WeightedMapDef enables setting weights for edits between related characters and substrings.
+ *
+ * Multiple groups can be defined using a `|`.
+ * A multi-character substring is defined using `()`.
+ *
+ * For example, in some languages, some letters sound alike.
+ *
+ * ```yaml
+ *   map: 'sc(sh)(sch)(ss)|t(tt)' # two groups.
+ *   replace: 50    # Make it 1/2 the cost of a normal edit to replace a `t` with `tt`.
+ * ```
+ *
+ * The following could be used to make inserting, removing, or replacing vowels cheaper.
+ * ```yaml
+ *   map: 'aeiouy'
+ *   insDel: 50     # Make it is cheaper to insert or delete a vowel.
+ *   replace: 45    # It is even cheaper to replace one with another.
+ * ```
+ *
+ * Note: the default edit distance is 100.
+ */
+export type SuggestionCostMapDef = CostMapDefReplace | CostMapDefInsDel | CostMapDefSwap;
+export type SuggestionCostsDefs = SuggestionCostMapDef[];
+interface CostMapDefBase {
+    /**
+     * The set of substrings to map, these are generally single character strings.
+     *
+     * Multiple sets can be defined by using a `|` to separate them.
+     *
+     * Example: `"eéê|aåá"` contains two different sets.
+     *
+     * To add a multi-character substring use `()`.
+     *
+     * Example: `"f(ph)(gh)"` results in the following set: `f`, `ph`, `gh`.
+     *
+     * - To match the beginning of a word, use `^`: `"(^I)""`.
+     * - To match the end of a word, use `$`: `"(e$)(ing$)"`.
+     *
+     */
+    map: string;
+    /** The cost to insert/delete one of the substrings in the map. Note: insert/delete costs are symmetrical. */
+    insDel?: number;
+    /**
+     * The cost to replace of of the substrings in the map with another substring in the map.
+     * Example: Map['a', 'i']
+     * This would be the cost to substitute `a` with `i`: Like `bat` to `bit` or the reverse.
+     */
+    replace?: number;
+    /**
+     * The cost to swap two adjacent substrings found in the map.
+     * Example: Map['e', 'i']
+     * This represents the cost to change `ei` to `ie` or the reverse.
+     */
+    swap?: number;
+    /**
+     * A description to describe the purpose of the map.
+     */
+    description?: string;
+    /**
+     * Add a penalty to the final cost.
+     * This is used to discourage certain suggestions.
+     *
+     * Example:
+     * ```yaml
+     * # Match adding/removing `-` to the end of a word.
+     * map: "$(-$)"
+     * replace: 50
+     * penalty: 100
+     * ```
+     *
+     * This makes adding a `-` to the end of a word more expensive.
+     *
+     * Think of it as taking the toll way for speed but getting the bill later.
+     */
+    penalty?: number;
+}
+export interface CostMapDefReplace extends CostMapDefBase {
+    replace: number;
+}
+export interface CostMapDefInsDel extends CostMapDefBase {
+    insDel: number;
+}
+export interface CostMapDefSwap extends CostMapDefBase {
+    swap: number;
+}
+export {};
+//# sourceMappingURL=suggestionCostsDef.d.ts.map

package/dist/cjs/types.d.ts

@@ -0,0 +1,9 @@
+export type Serialize<T> = T extends Function ? never : T extends null ? null : T extends any[] ? SerializeArray<T> : T extends object ? SerializeObj<T> : Primitives<T>;
+type SerializeObj<T extends object> = {
+    [K in keyof T]: K extends string | number ? Serialize<T[K]> : never;
+};
+type SerializeArray<T extends Array<any>> = T extends [infer R] ? [Serialize<R>] : T extends [infer R0, infer R1] ? [Serialize<R0>, Serialize<R1>] : T extends [infer R0, infer R1, infer R2] ? [Serialize<R0>, Serialize<R1>, Serialize<R2>] : T extends Array<infer R> ? Serialize<R>[] : never;
+type Primitives<T> = Extract<T, number | string | null | boolean>;
+export type Serializable = number | string | boolean | null | object;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/CSpellReporter.d.ts

@@ -0,0 +1,103 @@
+import type { TextDocumentOffset, TextOffset } from './TextOffset.js';
+export interface Suggestion {
+    /**
+     * Word to suggest.
+     */
+    word: string;
+    /**
+     * `true` - if this suggestion can be an automatic fix.
+     */
+    isPreferred?: boolean;
+}
+export interface Issue extends Omit<TextDocumentOffset, 'doc'> {
+    /** text surrounding the issue text */
+    context: TextOffset;
+    /**
+     * true if the issue has been flagged as a forbidden word.
+     */
+    isFlagged?: boolean;
+    /**
+     * An optional array of replacement strings.
+     */
+    suggestions?: string[];
+    /**
+     * An optional array of suggestions.
+     */
+    suggestionsEx?: Suggestion[];
+    /**
+     * Issues are spelling issues unless otherwise specified.
+     */
+    issueType?: IssueType;
+    /**
+     * Optional message to show.
+     */
+    message?: string;
+}
+export declare enum IssueType {
+    spelling = 0,
+    directive = 1
+}
+export type MessageType = 'Debug' | 'Info' | 'Warning';
+export type MessageTypeLookup = {
+    [key in MessageType]: key;
+};
+export declare const MessageTypes: MessageTypeLookup;
+export type MessageEmitter = (message: string, msgType: MessageType) => void;
+export type DebugEmitter = (message: string) => void;
+export type ErrorLike = Error | {
+    message: string;
+    name: string;
+    toString: () => string;
+};
+export type ErrorEmitter = (message: string, error: ErrorLike) => void;
+export type SpellingErrorEmitter = (issue: Issue) => void;
+export type ProgressTypes = 'ProgressFileBegin' | 'ProgressFileComplete';
+export type ProgressItem = ProgressFileBegin | ProgressFileComplete;
+export interface ProgressBase {
+    type: ProgressTypes;
+}
+export interface ProgressFileBase extends ProgressBase {
+    type: ProgressTypes;
+    fileNum: number;
+    fileCount: number;
+    filename: string;
+}
+export interface ProgressFileComplete extends ProgressFileBase {
+    type: 'ProgressFileComplete';
+    elapsedTimeMs: number | undefined;
+    processed: boolean | undefined;
+    numErrors: number | undefined;
+    cached?: boolean;
+}
+/**
+ * Notification sent just before processing a file.
+ */
+export interface ProgressFileBegin extends ProgressFileBase {
+    type: 'ProgressFileBegin';
+}
+export type ProgressEmitter = (p: ProgressItem | ProgressFileComplete) => void;
+export interface RunResult {
+    /** Number of files processed. */
+    files: number;
+    /** Set of files where issues were found. */
+    filesWithIssues: Set<string>;
+    /** Number of issues found. */
+    issues: number;
+    /** Number of processing errors. */
+    errors: number;
+    /** Number files that used results from the cache. */
+    cachedFiles?: number;
+}
+export type ResultEmitter = (result: RunResult) => void | Promise<void>;
+export interface CSpellReporter {
+    issue: SpellingErrorEmitter;
+    info: MessageEmitter;
+    debug: DebugEmitter;
+    error: ErrorEmitter;
+    progress: ProgressEmitter;
+    result: ResultEmitter;
+}
+export interface CSpellReporterModule {
+    getReporter: (settings: unknown) => CSpellReporter;
+}
+//# sourceMappingURL=CSpellReporter.d.ts.map

package/dist/esm/CSpellReporter.js

@@ -0,0 +1,11 @@
+export var IssueType;
+(function (IssueType) {
+    IssueType[IssueType["spelling"] = 0] = "spelling";
+    IssueType[IssueType["directive"] = 1] = "directive";
+})(IssueType = IssueType || (IssueType = {}));
+export const MessageTypes = {
+    Debug: 'Debug',
+    Info: 'Info',
+    Warning: 'Warning',
+};
+//# sourceMappingURL=CSpellReporter.js.map