editorconfig 2.0.1 → 3.0.1

package/lib/cli.test.d.ts

@@ -0,0 +1 @@
+import 'chai/register-should.js';

package/lib/cli.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("chai/register-should.js");
+const cli_js_1 = __importDefault(require("./cli.js"));
+async function exec(...args) {
+    const out = [];
+    const err = [];
+    const res = {
+        stdout: '',
+        stderr: '',
+    };
+    try {
+        res.props = await (0, cli_js_1.default)(['node', 'editorconfig', ...args], {
+            writeOut(s) {
+                out.push(s);
+            },
+            writeErr(s) {
+                err.push(s);
+            },
+        });
+    }
+    catch (er) {
+        res.err = er;
+    }
+    if (out.length) {
+        res.stdout = out.join('');
+    }
+    if (err.length) {
+        res.stderr = err.join('');
+    }
+    return res;
+}
+describe('Command line interface', () => {
+    it('helps', async () => {
+        const res = await exec('--help');
+        res.stdout.should.match(/^Usage:/);
+    });
+    it('Lists files', async () => {
+        const res = await exec('foo.md', '--files');
+        res.stdout.trim().should.match(/\.editorconfig \[\*\.md\]$/);
+    });
+    it('Lists multiple files', async () => {
+        const res = await exec('foo.md', 'bar.js', '--files');
+        res.stdout.should.match(/^\[foo\.md\]/);
+        res.stdout.trim().should.match(/\.editorconfig \[\*\]$/);
+    });
+});

package/lib/index.d.ts

@@ -1,24 +1,70 @@
 import { Buffer } from 'node:buffer';
 import { Minimatch } from 'minimatch';
 export interface KnownProps {
+    /**
+    * Specifies the character set. Use of `utf-8-bom` is discouraged.
+    */
+    charset?: 'latin1' | 'utf-8' | 'utf-8-bom' | 'utf-16be' | 'utf-16le' | 'unset';
+    /**
+    * Specifies how line breaks are represented.
+    */
     end_of_line?: 'lf' | 'crlf' | 'unset';
-    indent_style?: 'tab' | 'space' | 'unset';
+    /**
+    * Specifies the number of columns used for each indentation level
+    * and the width of soft tabs (when supported).
+    *
+    * If `indent_size` in the config is set to `tab`,
+    * the value of this property will be:
+    * - the same as the value of the {@link KnownProps.tab_width tab_width}
+    * if it is specified;
+    * - `tab` if it is not.
+    */
     indent_size?: number | 'tab' | 'unset';
+    /**
+     * Specifies whether tabs or spaces should be used for indentation.
+     * - `tab`: Use hard tabs for indentation,
+     * filling the remainder with spaces if needed.
+     * - `space`: Use spaces for indentation.
+     */
+    indent_style?: 'tab' | 'space' | 'unset';
+    /**
+    * Specifies whether a file should end with a newline character when saved.
+    * - `true`: Ensure the file ends with a newline.
+    * - `false`: Ensure the file does not end with a newline.
+    *
+    * Editors must not insert newlines in empty files
+    * when saving those files, even if `insert_final_newline` = true.
+    */
     insert_final_newline?: true | false | 'unset';
+    /**
+    * Specifies the number of columns used to represent a tab character.
+    *
+    * This defaults to the value of {@link KnownProps.indent_size indent_size}
+    * and should not usually need to be specified.
+    */
     tab_width?: number | 'unset';
+    /**
+     * Specifies whether all whitespace characters
+     * preceding newline characters in the file should be removed.
+     * - `true`: Remove all trailing whitespace before newlines.
+     * - `false`: Preserve trailing whitespace.
+     */
     trim_trailing_whitespace?: true | false | 'unset';
-    charset?: string | 'unset';
 }
-interface UnknownMap {
+export interface UnknownMap {
     [index: string]: unknown;
 }
-export type Props = KnownProps & UnknownMap;
+export type PossibleValue = boolean | number | (string & {});
+export type AddPossibleValues<T extends object> = {
+    [K in keyof T]: T[K] | PossibleValue;
+};
+export type Props = AddPossibleValues<KnownProps> & UnknownMap;
 export interface ECFile {
     name: string;
     contents?: Buffer;
 }
-type SectionGlob = Minimatch | null;
-type GlobbedProps = [SectionName, Props, SectionGlob][];
+export type SectionGlob = Minimatch | null;
+export type GlobbedProps = [SectionName, Props, SectionGlob][];
 export interface ProcessedFileConfig {
     root: boolean;
     name: string;
@@ -60,7 +106,7 @@ export declare function parseBuffer(data: Buffer): ParseStringResult;
  *
  * @param data String to parse.
  * @returns Parsed contents.  Will be truncated if there was a parse error.
- * @deprecated Use {@link ParseBuffer} instead.
+ * @deprecated Use {@link parseBuffer} instead.
  */
 export declare function parseString(data: string): ParseStringResult;
 /**
@@ -125,4 +171,3 @@ export declare function parseSync(filepath: string, options?: ParseOptions): Pro
  * @private
  */
 export declare function matcher(options: ParseOptions, ...buffers: Buffer[]): (filepath: string) => Props;
-export {};

package/lib/index.js

@@ -54,12 +54,13 @@ const package_json_1 = __importDefault(require("../package.json"));
 const escapedSep = new RegExp(path.sep.replace(/\\/g, '\\\\'), 'g');
 const matchOptions = { matchBase: true, dot: true };
 const knownPropNames = [
+    'charset',
     'end_of_line',
-    'indent_style',
     'indent_size',
+    'indent_style',
     'insert_final_newline',
+    // 'tab_width' // This should be an integer, not a string.
     'trim_trailing_whitespace',
-    'charset',
 ];
 const knownProps = new Set(knownPropNames);
 /**
@@ -103,7 +104,7 @@ function parseBuffer(data) {
  *
  * @param data String to parse.
  * @returns Parsed contents.  Will be truncated if there was a parse error.
- * @deprecated Use {@link ParseBuffer} instead.
+ * @deprecated Use {@link parseBuffer} instead.
  */
 function parseString(data) {
     return parseBuffer(node_buffer_1.Buffer.from(data));

package/lib/index.test.d.ts

@@ -0,0 +1 @@
+import 'chai/register-should.js';

package/lib/index.test.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-deprecated */
+require("chai/register-should.js");
+const editorconfig = __importStar(require("./index.js"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_buffer_1 = require("node:buffer");
+describe('parse', () => {
+    const expected = {
+        indent_style: 'space',
+        indent_size: 2,
+        end_of_line: 'lf',
+        charset: 'utf-8',
+        trim_trailing_whitespace: true,
+        insert_final_newline: true,
+        tab_width: 2,
+        block_comment: '*',
+        block_comment_end: '*/',
+        block_comment_start: '/**',
+    };
+    const target = path.join(__dirname, '/app.js');
+    it('async', async () => {
+        const cfg = await editorconfig.parse(target);
+        cfg.should.eql(expected);
+    });
+    it('sync', () => {
+        const visited = [];
+        const cfg = editorconfig.parseSync(target, { files: visited });
+        cfg.should.eql(expected);
+        visited.should.have.lengthOf(1);
+        visited[0].glob.should.eql('*');
+        visited[0].fileName.should.match(/\.editorconfig$/);
+    });
+    it('caches', async () => {
+        const cache = new Map();
+        const cfg = await editorconfig.parse(target, { cache });
+        cfg.should.eql(expected);
+        cache.size.should.be.eql(2);
+        await editorconfig.parse(target, { cache });
+        cache.size.should.be.eql(2);
+    });
+    it('caches sync', () => {
+        const cache = new Map();
+        const cfg = editorconfig.parseSync(target, { cache });
+        cfg.should.eql(expected);
+        cache.size.should.be.eql(2);
+        editorconfig.parseSync(target, { cache });
+        cache.size.should.be.eql(2);
+    });
+});
+describe('parseFromFiles', () => {
+    const expected = {
+        block_comment_end: '*/',
+        block_comment_start: '/**',
+        block_comment: '*',
+        charset: 'utf-8',
+        end_of_line: 'lf',
+        indent_size: 2,
+        indent_style: 'space',
+        insert_final_newline: true,
+        tab_width: 2,
+        trim_trailing_whitespace: true,
+    };
+    const configs = [];
+    const configPath = path.resolve(__dirname, '../.editorconfig');
+    configs.push({
+        name: configPath,
+        contents: fs.readFileSync(configPath),
+    });
+    const target = path.join(__dirname, '/app.js');
+    const configs2 = [
+        { name: 'early', contents: node_buffer_1.Buffer.alloc(0) },
+        configs[0],
+    ];
+    it('async', async () => {
+        const cfg = await editorconfig.parseFromFiles(target, Promise.resolve(configs));
+        cfg.should.eql(expected);
+    });
+    it('sync', () => {
+        const cfg = editorconfig.parseFromFilesSync(target, configs);
+        cfg.should.eql(expected);
+    });
+    it('handles null', () => {
+        const cfg = editorconfig.parseFromFilesSync(target, [{
+                name: configPath,
+                contents: node_buffer_1.Buffer.from('[*]\nfoo = null\n'),
+            }]);
+        cfg.should.eql({ foo: 'null' });
+    });
+    it('caches async', async () => {
+        const cache = new Map();
+        const cfg = await editorconfig.parseFromFiles(target, Promise.resolve(configs2), { cache });
+        cfg.should.eql(expected);
+        cache.size.should.be.eql(2);
+        const cfg2 = await editorconfig.parseFromFiles(target, Promise.resolve(configs2), { cache });
+        cfg2.should.eql(expected);
+        cache.size.should.be.eql(2);
+    });
+    it('caches sync', () => {
+        const cache = new Map();
+        const cfg = editorconfig.parseFromFilesSync(target, configs2, { cache });
+        cfg.should.eql(expected);
+        cache.size.should.be.eql(2);
+        const cfg2 = editorconfig.parseFromFilesSync(target, configs2, { cache });
+        cfg2.should.eql(expected);
+        cache.size.should.be.eql(2);
+    });
+    it('handles minimatch escapables', () => {
+        // Note that this `#` does not actually test the /^#/ escaping logic,
+        // because this path will go through a `path.dirname` before that happens.
+        // It's here to catch what would happen if minimatch started to treat #
+        // differently inside a pattern.
+        const bogusPath = path.resolve(__dirname, '#?*+@!()|[]{}');
+        const escConfigs = [
+            {
+                name: `${bogusPath}/.editorconfig`,
+                contents: configs[0].contents,
+            },
+        ];
+        const escTarget = `${bogusPath}/app.js`;
+        const cfg = editorconfig.parseFromFilesSync(escTarget, escConfigs);
+        cfg.should.eql(expected);
+    });
+});
+describe('parseString', () => {
+    const expected = [
+        [null, { root: 'true' }],
+        ['*', {
+                block_comment_end: '*/',
+                block_comment_start: '/**',
+                block_comment: '*',
+                charset: 'utf-8',
+                end_of_line: 'lf',
+                indent_size: '2',
+                indent_style: 'space',
+                insert_final_newline: 'true',
+                trim_trailing_whitespace: 'true',
+            }],
+        ['*.md', { indent_size: '4' }],
+    ];
+    const configPath = path.resolve(__dirname, '../.editorconfig');
+    const contents = fs.readFileSync(configPath, 'utf8');
+    it('sync', () => {
+        const cfg = editorconfig.parseString(contents);
+        cfg.should.eql(expected);
+    });
+    it('handles errors', () => {
+        const cfg = editorconfig.parseString('root: ');
+        cfg.should.eql([[null, {}]]);
+    });
+    it('handles backslashes in glob', () => {
+        const cfg = editorconfig.parseString('[a\\\\b]');
+        cfg.should.eql([[null, {}], ['a\\\\b', {}]]);
+    });
+    it('handles blank comments', () => {
+        const cfg = editorconfig.parseString('#');
+        cfg.should.eql([[null, {}]]);
+    });
+});
+describe('extra behavior', () => {
+    it('handles extended globs', () => {
+        // These failed when we had noext: true in matchOptions
+        const matcher = editorconfig.matcher({
+            root: __dirname,
+        }, node_buffer_1.Buffer.from(`\
+[*]
+indent_size = 4
+
+[!(package).json]
+indent_size = 3`));
+        matcher(path.join(__dirname, 'package.json')).should.include({ indent_size: 4 });
+        matcher(path.join(__dirname, 'foo.json')).should.include({ indent_size: 3 });
+    });
+});
+describe('unset', () => {
+    it('pair witht the value `unset`', () => {
+        const matcher = editorconfig.matcher({
+            root: __dirname,
+            unset: true,
+        }, node_buffer_1.Buffer.from(`\
+[*]
+indent_size = 4
+
+[*.json]
+indent_size = unset
+`));
+        matcher(path.join(__dirname, 'index.js')).should.include({ indent_size: 4 });
+        matcher(path.join(__dirname, 'index.json')).should.be.eql({});
+    });
+});

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "editorconfig",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "EditorConfig File Locator and Interpreter for Node.js",
   "keywords": [
     "editorconfig",
     "core"
   ],
   "main": "./lib/index.js",
+  "files": [
+    "lib/*",
+    "bin/*"
+  ],
   "contributors": [
     "Hong Xu (topbug.net)",
     "Jed Mao (https://github.com/jedmao/)",
     "Trey Hunner (http://treyhunner.com)",
-    "Joe Hildebrand (https://github.com/hildjj/)"
+    "Joe Hildebrand (https://github.com/hildjj/)",
+    "SunsetTechuila (https://github.com/SunsetTechuila/)"
   ],
   "directories": {
     "bin": "./bin",
@@ -26,11 +31,11 @@
   "license": "MIT",
   "dependencies": {
     "@one-ini/wasm": "0.2.0",
-    "commander": "^13.1.0",
+    "commander": "^14.0.0",
     "minimatch": "10.0.1",
-    "semver": "^7.7.1"
+    "semver": "^7.7.2"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   }
 }

package/eslint.config.mjs

@@ -1,13 +0,0 @@
-import base from '@cto.af/eslint-config';
-import ts from '@cto.af/eslint-config/ts.js';
-
-export default [
-  {
-    ignores: [
-      'lib/**',
-      '**/*.d.ts',
-    ],
-  },
-  ...base,
-  ...ts,
-];