@sheplu/editorconfig 0.8.7 → 0.10.0

package/src/templates/custom-template.js

@@ -0,0 +1,123 @@
+import {
+	AVAILABLE_LANGUAGES,
+	BASE_SECTION_HEADER,
+	headerToLanguage,
+	languageToHeader,
+	parseSections,
+} from './index.js';
+import { readTemplateText } from './template-source.js';
+
+const HEADER_LINE = /^\[.*\]$/u;
+const NO_HEADER = '';
+
+function knownHeaders() {
+	return [BASE_SECTION_HEADER, ...AVAILABLE_LANGUAGES.map((name) => languageToHeader(name))];
+}
+
+function languageForHeader(header) {
+	if (header === BASE_SECTION_HEADER) {
+		return 'base';
+	}
+	return headerToLanguage(header);
+}
+
+function trimTrailingBlankLines(lines) {
+	while (lines.length > 0 && lines.at(-1).trim() === '') {
+		lines.pop();
+	}
+}
+
+function flushBlock(state, blocks) {
+	if (state.header === NO_HEADER) {
+		return;
+	}
+	trimTrailingBlankLines(state.lines);
+	blocks.set(state.header, [state.header, ...state.lines].join('\n'));
+}
+
+function processLine(state, blocks, line) {
+	const trimmed = line.trim();
+	if (HEADER_LINE.test(trimmed)) {
+		flushBlock(state, blocks);
+		state.header = trimmed;
+		state.lines = [];
+		return;
+	}
+	if (state.header !== NO_HEADER) {
+		state.lines.push(line);
+	}
+}
+
+function extractRawSections(text) {
+	const normalized = text.replaceAll(/\r\n?/gu, '\n');
+	const blocks = new Map();
+	const state = { header: NO_HEADER, lines: [] };
+	for (const line of normalized.split('\n')) {
+		processLine(state, blocks, line);
+	}
+	flushBlock(state, blocks);
+	return blocks;
+}
+
+function rejectUnknownHeader(path, header) {
+	throw new Error(
+		`custom template '${path}' has unknown header '${header}'. Allowed: ${knownHeaders().join(', ')}`,
+	);
+}
+
+function rejectDuplicate(path, header) {
+	throw new Error(
+		`custom template '${path}' declares header '${header}' more than once`,
+	);
+}
+
+function ingestSection({ path, section, accumulator }) {
+	const language = languageForHeader(section.header);
+	if (!language) {
+		rejectUnknownHeader(path, section.header);
+		return;
+	}
+	if (accumulator.seen.has(language)) {
+		rejectDuplicate(path, section.header);
+		return;
+	}
+	accumulator.seen.add(language);
+	accumulator.bodies.set(language, section.body);
+}
+
+function buildBodies(path, sections) {
+	const accumulator = { bodies: new Map(), seen: new Set() };
+	for (const section of sections) {
+		ingestSection({ path, section, accumulator });
+	}
+	return accumulator.bodies;
+}
+
+function rawSectionFor(language, rawBlocks) {
+	if (language === 'base') {
+		return `root = true\n\n${rawBlocks.get(BASE_SECTION_HEADER)}`;
+	}
+	return rawBlocks.get(languageToHeader(language));
+}
+
+function buildRawSections(bodies, text) {
+	const rawBlocks = extractRawSections(text);
+	const rawSections = new Map();
+	for (const language of bodies.keys()) {
+		rawSections.set(language, rawSectionFor(language, rawBlocks));
+	}
+	return rawSections;
+}
+
+export async function loadCustomTemplate(input) {
+	const text = await readTemplateText(input);
+	const parsed = parseSections(text);
+	const bodies = buildBodies(input, parsed.sections);
+	if (bodies.has('base') && !parsed.hasRoot) {
+		throw new Error(
+			`custom template '${input}' redefines [*] but is missing 'root = true' in the preamble`,
+		);
+	}
+	const rawSections = buildRawSections(bodies, text);
+	return { bodies, rawSections, hasRoot: parsed.hasRoot };
+}

package/src/templates/dockerfile.js

@@ -0,0 +1,4 @@
+export const dockerfile = `[{Dockerfile,Dockerfile.*,*.dockerfile}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/go.js

@@ -0,0 +1,5 @@
+export const go = `[*.go]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+`;

package/src/templates/html.js

@@ -0,0 +1,4 @@
+export const html = `[*.{html,htm}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/index.js

@@ -0,0 +1,277 @@
+import { base } from './base.js';
+import { javascript } from './javascript.js';
+import { yaml } from './yaml.js';
+import { markdown } from './markdown.js';
+import { python } from './python.js';
+import { go } from './go.js';
+import { rust } from './rust.js';
+import { terraform } from './terraform.js';
+import { json } from './json.js';
+import { toml } from './toml.js';
+import { shell } from './shell.js';
+import { makefile } from './makefile.js';
+import { dockerfile } from './dockerfile.js';
+import { html } from './html.js';
+import { css } from './css.js';
+
+export {
+	base,
+	javascript,
+	yaml,
+	markdown,
+	python,
+	go,
+	rust,
+	terraform,
+	json,
+	toml,
+	shell,
+	makefile,
+	dockerfile,
+	html,
+	css,
+};
+
+export const AVAILABLE_LANGUAGES = [
+	'javascript',
+	'yaml',
+	'markdown',
+	'python',
+	'go',
+	'rust',
+	'terraform',
+	'json',
+	'toml',
+	'shell',
+	'makefile',
+	'dockerfile',
+	'html',
+	'css',
+];
+
+export const ALIASES = {
+	js: 'javascript',
+	jsx: 'javascript',
+	ts: 'javascript',
+	tsx: 'javascript',
+	mjs: 'javascript',
+	cjs: 'javascript',
+	yml: 'yaml',
+	md: 'markdown',
+	py: 'python',
+	rs: 'rust',
+	tf: 'terraform',
+	tfvars: 'terraform',
+	sh: 'shell',
+	bash: 'shell',
+	zsh: 'shell',
+	mk: 'makefile',
+	htm: 'html',
+	scss: 'css',
+	sass: 'css',
+	less: 'css',
+};
+
+const LANGUAGE_TEMPLATES = {
+	javascript,
+	yaml,
+	markdown,
+	python,
+	go,
+	rust,
+	terraform,
+	json,
+	toml,
+	shell,
+	makefile,
+	dockerfile,
+	html,
+	css,
+};
+
+function joinSections(sections) {
+	return `${sections
+		.map((section) => section.replace(/\n+$/u, ''))
+		.join('\n\n')}\n`;
+}
+
+export const EMPTY_OVERRIDES = Object.freeze({
+	bodies: new Map(),
+	rawSections: new Map(),
+	hasRoot: false,
+});
+
+function pickSection(name, builtin, overrides) {
+	if (overrides.rawSections.has(name)) {
+		return overrides.rawSections.get(name);
+	}
+	return builtin;
+}
+
+export function composeEditorConfig(languageNames = [], overrides = EMPTY_OVERRIDES) {
+	const resolved = new Set();
+	for (const raw of languageNames) {
+		const name = ALIASES[raw] ?? raw;
+		if (!Object.hasOwn(LANGUAGE_TEMPLATES, name)) {
+			throw new Error(
+				`unknown language: '${raw}'. Available: ${AVAILABLE_LANGUAGES.join(', ')}`,
+			);
+		}
+		resolved.add(name);
+	}
+	const ordered = AVAILABLE_LANGUAGES.filter((name) => resolved.has(name));
+	const sections = [
+		pickSection('base', base, overrides),
+		...ordered.map((name) => pickSection(name, LANGUAGE_TEMPLATES[name], overrides)),
+	];
+	return joinSections(sections);
+}
+
+export const editorconfigContent = composeEditorConfig(AVAILABLE_LANGUAGES);
+
+const BASE_HEADER = '[*]';
+
+function extractHeader(template) {
+	return template.split('\n', 1)[0];
+}
+
+const HEADER_TO_LANGUAGE = new Map(
+	AVAILABLE_LANGUAGES.map((name) => [extractHeader(LANGUAGE_TEMPLATES[name]), name]),
+);
+
+export function headerToLanguage(header) {
+	return HEADER_TO_LANGUAGE.get(header);
+}
+
+function isIgnoredLine(line) {
+	if (line === '' || line.startsWith('#') || line.startsWith(';')) {
+		return true;
+	}
+	if (line.startsWith('[') && line.endsWith(']')) {
+		return true;
+	}
+	return false;
+}
+
+function applyKeyValue(body, line) {
+	const equalsAt = line.indexOf('=');
+	if (equalsAt === -1) {
+		return;
+	}
+	const key = line.slice(0, equalsAt).trim().toLowerCase();
+	if (key.length === 0) {
+		return;
+	}
+	body.set(key, line.slice(equalsAt + 1).trim());
+}
+
+export function parseSection(block) {
+	const body = new Map();
+	for (const rawLine of block.split('\n')) {
+		const line = rawLine.trim();
+		if (!isIgnoredLine(line)) {
+			applyKeyValue(body, line);
+		}
+	}
+	return body;
+}
+
+function finishSection({ header, lines }) {
+	return {
+		header,
+		body: parseSection(lines.join('\n')),
+	};
+}
+
+function processLine(state, line) {
+	const trimmed = line.trim();
+	if (/^\[.*\]$/u.test(trimmed)) {
+		if (state.current) {
+			state.sections.push(finishSection(state.current));
+		}
+		state.current = { header: trimmed, lines: [] };
+	}
+	else if (state.current) {
+		state.current.lines.push(line);
+	}
+	else {
+		state.preamble.push(line);
+	}
+}
+
+function splitSections(lines) {
+	const state = { sections: [], preamble: [], current: false };
+	for (const line of lines) {
+		processLine(state, line);
+	}
+	if (state.current) {
+		state.sections.push(finishSection(state.current));
+	}
+	return { sections: state.sections, preamble: state.preamble };
+}
+
+export function parseSections(text) {
+	const normalized = text.replaceAll(/\r\n?/gu, '\n');
+	const { sections, preamble } = splitSections(normalized.split('\n'));
+	const hasRoot = preamble.some((line) => /^\s*root\s*=\s*true\s*$/iu.test(line));
+	return { hasRoot, sections };
+}
+
+export function compareSection(actualBody, expectedBody) {
+	if (actualBody.size !== expectedBody.size) {
+		return { ok: false };
+	}
+	for (const [key, value] of expectedBody) {
+		if (!actualBody.has(key) || actualBody.get(key) !== value) {
+			return { ok: false };
+		}
+	}
+	return { ok: true };
+}
+
+function bodyAfterHeader(template) {
+	const headerEnd = template.indexOf('\n');
+	return template.slice(headerEnd + 1);
+}
+
+function bodyAfterFirstHeader(template) {
+	const lines = template.split('\n');
+	const headerIndex = lines.findIndex((line) => /^\[.*\]$/u.test(line.trim()));
+	if (headerIndex === -1) {
+		return template;
+	}
+	return lines.slice(headerIndex + 1).join('\n');
+}
+
+export function expectedBodyForLanguage(language, overrides = EMPTY_OVERRIDES) {
+	if (overrides.bodies.has(language)) {
+		return overrides.bodies.get(language);
+	}
+	if (language === 'base') {
+		return parseSection(bodyAfterFirstHeader(base));
+	}
+	return parseSection(bodyAfterHeader(LANGUAGE_TEMPLATES[language]));
+}
+
+export function resolveLanguageNames(languageNames) {
+	const resolved = new Set();
+	for (const raw of languageNames) {
+		const name = ALIASES[raw] ?? raw;
+		if (!Object.hasOwn(LANGUAGE_TEMPLATES, name)) {
+			throw new Error(
+				`unknown language: '${raw}'. Available: ${AVAILABLE_LANGUAGES.join(', ')}`,
+			);
+		}
+		resolved.add(name);
+	}
+	return AVAILABLE_LANGUAGES.filter((name) => resolved.has(name));
+}
+
+export function languageToHeader(language) {
+	if (language === 'base') {
+		return BASE_HEADER;
+	}
+	return extractHeader(LANGUAGE_TEMPLATES[language]);
+}
+
+export const BASE_SECTION_HEADER = BASE_HEADER;

package/src/templates/javascript.js

@@ -0,0 +1,6 @@
+export const javascript = `[*.{js,jsx,ts,tsx,mjs,cjs}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+quote_type = single
+`;

package/src/templates/json.js

@@ -0,0 +1,4 @@
+export const json = `[*.json]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/makefile.js

@@ -0,0 +1,5 @@
+export const makefile = `[{Makefile,GNUmakefile,makefile,*.mk}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+`;

package/src/templates/markdown.js

@@ -0,0 +1,5 @@
+export const markdown = `[*.md]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = false
+`;

package/src/templates/python.js

@@ -0,0 +1,5 @@
+export const python = `[*.py]
+indent_style = space
+indent_size = 4
+max_line_length = 88
+`;

package/src/templates/rust.js

@@ -0,0 +1,5 @@
+export const rust = `[*.rs]
+indent_style = space
+indent_size = 4
+max_line_length = 100
+`;

package/src/templates/shell.js

@@ -0,0 +1,4 @@
+export const shell = `[*.{sh,bash,zsh}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/template-source.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { fetchTemplate } from '../utils/fetch.js';
+import { isHttpScheme, tryParseUrl } from '../utils/url.js';
+
+function readLocalFile(path) {
+	if (!existsSync(path)) {
+		throw new Error(`custom template '${path}' does not exist`);
+	}
+	return readFileSync(path, 'utf8');
+}
+
+export async function readTemplateText(input) {
+	if (typeof input !== 'string' || input.trim() === '') {
+		throw new Error('--template requires a path or URL to a custom template');
+	}
+	const url = tryParseUrl(input);
+	if (url && isHttpScheme(url)) {
+		if (url.protocol !== 'https:') {
+			throw new Error(`--template URL must use https (got '${url.protocol.replace(':', '')}')`);
+		}
+		return await fetchTemplate(url.href);
+	}
+	return readLocalFile(input);
+}

package/src/templates/terraform.js

@@ -0,0 +1,4 @@
+export const terraform = `[*.{tf,tfvars}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/toml.js

@@ -0,0 +1,4 @@
+export const toml = `[*.toml]
+indent_style = space
+indent_size = 4
+`;

package/src/templates/yaml.js

@@ -0,0 +1,4 @@
+export const yaml = `[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+`;

package/src/utils/fetch.js

@@ -0,0 +1,107 @@
+import { parseRedirectLocation } from './url.js';
+
+const TIMEOUT_MS = 10_000;
+const MS_PER_SECOND = 1000;
+const MAX_BYTES = 1_048_576;
+const MAX_REDIRECTS = 5;
+const HTTP_REDIRECT_MIN = 300;
+const HTTP_REDIRECT_MAX = 400;
+
+function ignoreCancelError() {
+	return false;
+}
+
+export function isRedirect(status) {
+	return status >= HTTP_REDIRECT_MIN && status < HTTP_REDIRECT_MAX;
+}
+
+export function rejectOversized(url) {
+	throw new Error(`template body for '${url}' exceeds 1 MB limit`);
+}
+
+export function checkContentLength(response, url) {
+	const header = response.headers.get('content-length');
+	if (header === null) {
+		return;
+	}
+	const bytes = Number.parseInt(header, 10);
+	if (Number.isFinite(bytes) && bytes > MAX_BYTES) {
+		rejectOversized(url);
+	}
+}
+
+export function decodeChunks(chunks) {
+	return new TextDecoder('utf-8').decode(Buffer.concat(chunks));
+}
+
+export function appendChunk({ state, value, reader, url }) {
+	state.total += value.byteLength;
+	if (state.total > MAX_BYTES) {
+		// We're about to throw rejectOversized; swallow any cancel() rejection.
+		reader.cancel().catch(ignoreCancelError);
+		rejectOversized(url);
+	}
+	state.chunks.push(value);
+}
+
+export async function consumeStream(reader, url) {
+	const state = { chunks: [], total: 0 };
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const { value, done } = await reader.read();
+		if (done) {
+			return decodeChunks(state.chunks);
+		}
+		appendChunk({ state, value, reader, url });
+	}
+}
+
+export async function readBoundedBody(response, url) {
+	checkContentLength(response, url);
+	return await consumeStream(response.body.getReader(), url);
+}
+
+export function resolveRedirect(response, currentUrl) {
+	const location = response.headers.get('location');
+	return parseRedirectLocation(location, currentUrl);
+}
+
+export async function performFetch(initialUrl, signal) {
+	let url = initialUrl;
+	for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+		// eslint-disable-next-line no-await-in-loop
+		const response = await fetch(url, { signal, redirect: 'manual' });
+		if (response.ok) {
+			return readBoundedBody(response, url);
+		}
+		if (!isRedirect(response.status)) {
+			throw new Error(`failed to fetch '${url}': HTTP ${response.status}`);
+		}
+		url = resolveRedirect(response, url);
+	}
+	throw new Error(`failed to fetch '${initialUrl}': too many redirects (max ${MAX_REDIRECTS})`);
+}
+
+export function describeFetchError(url, error) {
+	if (error.name === 'AbortError') {
+		return new Error(`failed to fetch '${url}': request timed out after ${TIMEOUT_MS / MS_PER_SECOND}s`);
+	}
+	if (/^failed to fetch |^template body /u.test(error.message)) {
+		return error;
+	}
+	return new Error(`failed to fetch '${url}': ${error.message}`);
+}
+
+export async function fetchTemplate(url) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+	try {
+		return await performFetch(url, controller.signal);
+	}
+	catch (error) {
+		throw describeFetchError(url, error);
+	}
+	finally {
+		clearTimeout(timer);
+	}
+}

package/src/utils/logger.js

@@ -0,0 +1,8 @@
+/* eslint-disable no-console */
+export const logger = {
+	log: (...args) => console.log(...args),
+	info: (...args) => console.info(...args),
+	warn: (...args) => console.warn(...args),
+	error: (...args) => console.error(...args),
+	debug: (...args) => console.debug(...args),
+};

package/src/utils/url.js

@@ -0,0 +1,23 @@
+export function tryParseUrl(input) {
+	try {
+		return new URL(input);
+	}
+	catch {
+		return false;
+	}
+}
+
+export function isHttpScheme(url) {
+	return url.protocol === 'http:' || url.protocol === 'https:';
+}
+
+export function parseRedirectLocation(location, currentUrl) {
+	if (typeof location !== 'string' || location.length === 0) {
+		throw new Error(`failed to fetch '${currentUrl}': redirect missing Location header`);
+	}
+	const next = new URL(location, currentUrl);
+	if (next.protocol !== 'https:') {
+		throw new Error(`failed to fetch '${currentUrl}': refused redirect to non-https '${next.href}'`);
+	}
+	return next.href;
+}

package/.github/workflows/npm-release.yaml

@@ -1,42 +0,0 @@
-name: Publish package
-on:
-  release:
-    types: [created]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: prod
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-
-      - name: NPM install
-        run: |
-          npm install
-
-      - name: Version
-        if: github.event_name == 'release' && github.event.action == 'created'
-        run: |
-          VERSION=${{ github.event.release.tag_name }}
-          VERSION=${VERSION:1}
-          CURRENT_VERSION=$(npm pkg get version | tr -d '"')
-          if [ "$CURRENT_VERSION" != "$VERSION" ]; then
-            npm version $VERSION --no-git-tag-version
-          else
-            echo "Version already set to $VERSION, skipping npm version command"
-          fi
-
-      - name: publish
-        run: |
-          npm publish --access public