vscode-eslint 0.0.2 → 0.0.4

package/client/out/node-utils.d.ts

@@ -0,0 +1,51 @@
+export declare namespace Is {
+    function boolean(value: any): value is boolean;
+    function string(value: any): value is string;
+    function objectLiteral(value: any): value is object;
+}
+/**
+ * Converts a path to the OS representation,
+ * @param path the path to convert.
+ * @returns the converted path.
+ */
+export declare function toOSPath(path: string): string;
+/**
+ * Converts a path to a posix path.
+ * @param path the path to convert.
+ * @returns the posix path.
+ */
+export declare function toPosixPath(path: string): string;
+/**
+ * Find a ESLint installation at a given root path.
+ * @param rootPath the root path.
+ * @returns the eslint installation or the unresolved command eslint.
+ */
+export declare function findEslint(rootPath: string): Promise<string>;
+/**
+ * Converts a pattern in string from to a regular expression.
+ *
+ * @param pattern the pattern as a string to be converted
+ * @returns the regular expression or undefined if the pattern can't be converted.
+ */
+export declare function convert2RegExp(pattern: string): RegExp | undefined;
+/**
+ * A semaphore implementation.
+ */
+export declare class Semaphore<T = void> {
+    private _capacity;
+    private _active;
+    private _waiting;
+    constructor(capacity?: number);
+    /**
+     * Takes a lock and executes the thunk.
+     * @param thunk the thunk to execute
+     * @returns a promise for the result of the thunk
+     */
+    lock(thunk: () => T | PromiseLike<T>): Promise<T>;
+    /**
+     * Returns the numbers of the active thunks.
+     */
+    get active(): number;
+    private runNext;
+    private doRunNext;
+}

package/client/out/settings.d.ts

@@ -0,0 +1,41 @@
+import { Uri } from 'vscode';
+export type ValidateItem = {
+    language: string;
+    autoFix?: boolean;
+};
+export declare namespace ValidateItem {
+    function is(item: any): item is ValidateItem;
+}
+export type LegacyDirectoryItem = {
+    directory: string;
+    changeProcessCWD: boolean;
+};
+export declare namespace LegacyDirectoryItem {
+    function is(item: any): item is LegacyDirectoryItem;
+}
+export type PatternItem = {
+    pattern: string;
+    '!cwd'?: boolean;
+};
+export declare namespace PatternItem {
+    function is(item: any): item is PatternItem;
+}
+export declare class Migration {
+    private workspaceConfig;
+    private eslintConfig;
+    private editorConfig;
+    private codeActionOnSave;
+    private languageSpecificSettings;
+    private autoFixOnSave;
+    private validate;
+    private workingDirectories;
+    private didChangeConfiguration;
+    constructor(resource: Uri);
+    record(): void;
+    captureDidChangeSetting(func: () => void): void;
+    private recordAutoFixOnSave;
+    private recordValidate;
+    private recordWorkingDirectories;
+    needsUpdate(): boolean;
+    update(): Promise<void>;
+}

package/client/out/shared/customMessages.d.ts

@@ -0,0 +1,89 @@
+import { NotificationType, NotificationType0, RequestType, TextDocumentIdentifier } from 'vscode-languageserver-protocol';
+export declare enum Status {
+    ok = 1,
+    warn = 2,
+    error = 3
+}
+export type StatusParams = {
+    uri: string;
+    state: Status;
+    validationTime?: number;
+};
+/**
+ * The status notification is sent from the server to the client to
+ * inform the client about server status changes.
+ */
+export declare namespace StatusNotification {
+    const method: 'eslint/status';
+    const type: NotificationType<StatusParams>;
+}
+export type NoConfigParams = {
+    message: string;
+    document: TextDocumentIdentifier;
+};
+export type NoConfigResult = {};
+/**
+ * The NoConfigRequest is sent from the server to the client to inform
+ * the client that no eslint configuration file could be found when
+ * trying to lint a file.
+ */
+export declare namespace NoConfigRequest {
+    const method: 'eslint/noConfig';
+    const type: RequestType<NoConfigParams, NoConfigResult, void>;
+}
+export type NoESLintLibraryParams = {
+    source: TextDocumentIdentifier;
+};
+export type NoESLintLibraryResult = {};
+/**
+ * The NoESLintLibraryRequest is sent from the server to the client to
+ * inform the client that no eslint library could be found when trying
+ * to lint a file.
+ */
+export declare namespace NoESLintLibraryRequest {
+    const method: 'eslint/noLibrary';
+    const type: RequestType<NoESLintLibraryParams, NoESLintLibraryResult, void>;
+}
+export type OpenESLintDocParams = {
+    url: string;
+};
+export type OpenESLintDocResult = {};
+/**
+ * The eslint/openDoc request is sent from the server to the client to
+ * ask the client to open the documentation URI for a given
+ * ESLint rule.
+ */
+export declare namespace OpenESLintDocRequest {
+    const method: 'eslint/openDoc';
+    const type: RequestType<OpenESLintDocParams, OpenESLintDocResult, void>;
+}
+export type ProbeFailedParams = {
+    textDocument: TextDocumentIdentifier;
+};
+/**
+ * The eslint/probeFailed request is sent from the server to the client
+ * to tell the client the the lint probing for a certain document has
+ * failed and that there is no need to sync that document to the server
+ * anymore.
+ */
+export declare namespace ProbeFailedRequest {
+    const method: 'eslint/probeFailed';
+    const type: RequestType<ProbeFailedParams, void, void>;
+}
+/**
+ * The eslint/showOutputChannel notification is sent from the server to
+ * the client to ask the client to reveal it's output channel.
+ */
+export declare namespace ShowOutputChannel {
+    const method: 'eslint/showOutputChannel';
+    const type: NotificationType0;
+}
+/**
+ * The eslint/exitCalled notification is sent from the server to the client
+ * to inform the client that a process.exit call on the server got intercepted.
+ * The call was very likely made by an ESLint plugin.
+ */
+export declare namespace ExitCalled {
+    const method: 'eslint/exitCalled';
+    const type: NotificationType<[number, string]>;
+}

package/client/out/shared/settings.d.ts

@@ -0,0 +1,106 @@
+import { WorkspaceFolder } from 'vscode-languageserver-protocol';
+export declare enum Validate {
+    on = "on",
+    off = "off",
+    probe = "probe"
+}
+export type CodeActionSettings = {
+    disableRuleComment: {
+        enable: boolean;
+        location: 'separateLine' | 'sameLine';
+        commentStyle: 'line' | 'block';
+    };
+    showDocumentation: {
+        enable: boolean;
+    };
+};
+export declare enum CodeActionsOnSaveMode {
+    all = "all",
+    problems = "problems"
+}
+export declare namespace CodeActionsOnSaveMode {
+    function from(value: string | undefined | null): CodeActionsOnSaveMode;
+}
+export declare namespace CodeActionsOnSaveRules {
+    function from(value: string[] | undefined | null): string[] | undefined;
+}
+export declare namespace CodeActionsOnSaveOptions {
+    function from(value: object | undefined | null): ESLintOptions | undefined;
+}
+export type CodeActionsOnSaveSettings = {
+    mode: CodeActionsOnSaveMode;
+    rules?: string[];
+    options?: ESLintOptions;
+};
+export declare enum ESLintSeverity {
+    off = "off",
+    warn = "warn",
+    error = "error"
+}
+export declare namespace ESLintSeverity {
+    function from(value: string | undefined | null): ESLintSeverity;
+}
+export declare enum RuleSeverity {
+    info = "info",
+    warn = "warn",
+    error = "error",
+    off = "off",
+    default = "default",
+    downgrade = "downgrade",
+    upgrade = "upgrade"
+}
+export type RuleCustomization = {
+    rule: string;
+    severity: RuleSeverity;
+    /** Only apply to autofixable rules */
+    fixable?: boolean;
+};
+export type RunValues = 'onType' | 'onSave';
+export declare enum ModeEnum {
+    auto = "auto",
+    location = "location"
+}
+export declare namespace ModeEnum {
+    function is(value: string): value is ModeEnum;
+}
+export type ModeItem = {
+    mode: ModeEnum;
+};
+export declare namespace ModeItem {
+    function is(item: any): item is ModeItem;
+}
+export type DirectoryItem = {
+    directory: string;
+    '!cwd'?: boolean;
+};
+export declare namespace DirectoryItem {
+    function is(item: any): item is DirectoryItem;
+}
+export type PackageManagers = 'npm' | 'yarn' | 'pnpm';
+export type ESLintOptions = object & {
+    fixTypes?: string[];
+};
+export type ConfigurationSettings = {
+    validate: Validate;
+    packageManager: PackageManagers;
+    useESLintClass: boolean;
+    useFlatConfig?: boolean | undefined;
+    useRealpaths: boolean;
+    experimental?: {
+        useFlatConfig: boolean;
+    };
+    codeAction: CodeActionSettings;
+    codeActionOnSave: CodeActionsOnSaveSettings;
+    format: boolean;
+    quiet: boolean;
+    onIgnoredFiles: ESLintSeverity;
+    options: ESLintOptions | undefined;
+    rulesCustomizations: RuleCustomization[];
+    run: RunValues;
+    problems: {
+        shortenToSingleLine: boolean;
+    };
+    nodePath: string | null;
+    workspaceFolder: WorkspaceFolder | undefined;
+    workingDirectory: ModeItem | DirectoryItem | undefined;
+};

package/client/out/tasks.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A task provider that adds ESLint checking tasks.
+ */
+export declare class TaskProvider {
+    /**
+     * A Disposable to unregister the task provider inside
+     * VS Code.
+     */
+    private taskProvider;
+    /**
+     * The actual providers per workspace folder.
+     */
+    private readonly providers;
+    /**
+     * A disposable to unregister event listeners
+     */
+    private disposable;
+    constructor();
+    start(): void;
+    dispose(): void;
+    /**
+     * The workspace folders have changed.
+     */
+    private updateWorkspaceFolders;
+    /**
+     * The configuration has changed.
+     */
+    private updateConfiguration;
+    private updateProvider;
+    private getTasks;
+}

package/client/out/tests/glob.test.d.ts

@@ -0,0 +1 @@
+export {};

package/client/out/vscode-utils.d.ts

@@ -0,0 +1,5 @@
+import { WorkspaceFolder } from 'vscode';
+/**
+ * Picks a folder from a list of workspace folders.
+ */
+export declare function pickFolder(folders: ReadonlyArray<WorkspaceFolder>, placeHolder: string): Promise<WorkspaceFolder | undefined>;

package/package.json

@@ -2,7 +2,7 @@
 "name": "vscode-eslint",
 	"displayName": "ESLint",
 	"description": "Integrates ESLint JavaScript into VS Code.",
-"version": "0.0.2",
+"version": "0.0.4",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -14,8 +14,15 @@
 	},
 	"publisher": "dbaeumer",
 	"bin": {
-		"vscode-eslint": "bin/vscode-eslint.js"
+		"vscode-eslint": "bin/vscode-eslint"
 	},
+	"files": [
+		"bin",
+		"client/out",
+		"server/out",
+		"shared",
+		"eslint_icon.png"
+	],
 	"icon": "eslint_icon.png",
 	"categories": [
 		"Programming Languages",

package/server/out/diff.d.ts

@@ -0,0 +1,134 @@
+export interface IDiffChange {
+    /**
+     * The position of the first element in the original sequence which
+     * this change affects.
+     */
+    originalStart: number;
+    /**
+     * The number of elements from the original sequence which were
+     * affected.
+     */
+    originalLength: number;
+    /**
+     * The position of the first element in the modified sequence which
+     * this change affects.
+     */
+    modifiedStart: number;
+    /**
+     * The number of elements from the modified sequence which were
+     * affected (added).
+     */
+    modifiedLength: number;
+}
+export declare function stringDiff(original: string, modified: string, pretty: boolean): IDiffChange[];
+interface ISequence {
+    getElements(): Int32Array;
+}
+interface IContinueProcessingPredicate {
+    (furthestOriginalIndex: number, matchLengthOfLongest: number): boolean;
+}
+interface IDiffResult {
+    quitEarly: boolean;
+    changes: IDiffChange[];
+}
+export declare class Debug {
+    static Assert(condition: boolean, message: string): void;
+}
+/**
+ * An implementation of the difference algorithm described in
+ * "An O(ND) Difference Algorithm and its variations" by Eugene W. Myers
+ */
+export declare class LcsDiff {
+    private readonly ContinueProcessingPredicate;
+    private readonly _hasStrings;
+    private readonly _originalStringElements;
+    private readonly _originalElementsOrHash;
+    private readonly _modifiedStringElements;
+    private readonly _modifiedElementsOrHash;
+    private m_forwardHistory;
+    private m_reverseHistory;
+    /**
+     * Constructs the DiffFinder
+     */
+    constructor(originalSequence: ISequence, modifiedSequence: ISequence, continueProcessingPredicate?: IContinueProcessingPredicate | null);
+    private static _getElements;
+    private ElementsAreEqual;
+    private OriginalElementsAreEqual;
+    private ModifiedElementsAreEqual;
+    ComputeDiff(pretty: boolean): IDiffResult;
+    /**
+     * Computes the differences between the original and modified input
+     * sequences on the bounded range.
+     * @returns An array of the differences between the two input sequences.
+     */
+    private _ComputeDiff;
+    /**
+     * Private helper method which computes the differences on the bounded range
+     * recursively.
+     * @returns An array of the differences between the two input sequences.
+     */
+    private ComputeDiffRecursive;
+    private WALKTRACE;
+    /**
+     * Given the range to compute the diff on, this method finds the point:
+     * (midOriginal, midModified)
+     * that exists in the middle of the LCS of the two sequences and
+     * is the point at which the LCS problem may be broken down recursively.
+     * This method will try to keep the LCS trace in memory. If the LCS recursion
+     * point is calculated and the full trace is available in memory, then this method
+     * will return the change list.
+     * @param originalStart The start bound of the original sequence range
+     * @param originalEnd The end bound of the original sequence range
+     * @param modifiedStart The start bound of the modified sequence range
+     * @param modifiedEnd The end bound of the modified sequence range
+     * @param midOriginal The middle point of the original sequence range
+     * @param midModified The middle point of the modified sequence range
+     * @returns The diff changes, if available, otherwise null
+     */
+    private ComputeRecursionPoint;
+    /**
+     * Shifts the given changes to provide a more intuitive diff.
+     * While the first element in a diff matches the first element after the diff,
+     * we shift the diff down.
+     *
+     * @param changes The list of changes to shift
+     * @returns The shifted changes
+     */
+    private PrettifyChanges;
+    private _OriginalIsBoundary;
+    private _OriginalRegionIsBoundary;
+    private _ModifiedIsBoundary;
+    private _ModifiedRegionIsBoundary;
+    private _boundaryScore;
+    /**
+     * Concatenates the two input DiffChange lists and returns the resulting
+     * list.
+     * @param The left changes
+     * @param The right changes
+     * @returns The concatenated list
+     */
+    private ConcatenateChanges;
+    /**
+     * Returns true if the two changes overlap and can be merged into a single
+     * change
+     * @param left The left change
+     * @param right The right change
+     * @param mergedChange The merged change if the two overlap, null otherwise
+     * @returns True if the two changes overlap
+     */
+    private ChangesOverlap;
+    /**
+     * Helper method used to clip a diagonal index to the range of valid
+     * diagonals. This also decides whether or not the diagonal index,
+     * if it exceeds the boundary, should be clipped to the boundary or clipped
+     * one inside the boundary depending on the Even/Odd status of the boundary
+     * and numDifferences.
+     * @param diagonal The index of the diagonal to clip.
+     * @param numDifferences The current number of differences being iterated upon.
+     * @param diagonalBaseIndex The base reference diagonal.
+     * @param numDiagonals The total number of diagonals.
+     * @returns The clipped diagonal index.
+     */
+    private ClipDiagonalBound;
+}
+export {};