kotlin-format 0.0.0-stage → 0.0.1

package/dist/config.d.mts

@@ -0,0 +1,21 @@
+export interface FormatConfig {
+  style?: "META" | "GOOGLE" | "KOTLINLANG";
+  maxWidth?: number;
+  removeUnusedImports?: boolean;
+  preserveLambdaBreaks?: boolean;
+}
+export declare function exists(path: string): Promise<boolean>;
+export declare function validateConfig(value: unknown, label?: string): FormatConfig;
+export declare function projectRoot(file: string): Promise<string>;
+/** Nearest config wins; stop at the supplied workspace root or nearest package/Git root. */
+export declare function loadConfig(file: string, options?: {
+  configPath?: string;
+  root?: string;
+  allowCode?: boolean;
+}): Promise<FormatConfig>;
+export interface ResolvedOptions extends Required<FormatConfig> {
+  blockIndent: number;
+  continuationIndent: number;
+  trailingCommas: string;
+}
+export declare function resolveOptions(config?: FormatConfig): ResolvedOptions;

package/dist/config.mjs

@@ -0,0 +1,105 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+// js/config.ts
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function validateConfig(value, label = "configuration") {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label}: expected an object`);
+	for (const [key, item] of Object.entries(value)) {
+		if (key === "$schema" && typeof item === "string") continue;
+		if (key === "style" && [
+			"META",
+			"GOOGLE",
+			"KOTLINLANG"
+		].includes(item)) continue;
+		if (key === "maxWidth" && Number.isInteger(item) && item >= 1 && item <= 999) continue;
+		if (["removeUnusedImports", "preserveLambdaBreaks"].includes(key) && typeof item === "boolean") continue;
+		throw new Error(`${label}: invalid option ${key}=${JSON.stringify(item)}`);
+	}
+	const { style, maxWidth, removeUnusedImports, preserveLambdaBreaks } = value;
+	return Object.fromEntries(Object.entries({
+		style,
+		maxWidth,
+		removeUnusedImports,
+		preserveLambdaBreaks
+	}).filter(([, v]) => v !== void 0));
+}
+async function projectRoot(file) {
+	let directory = dirname(resolve(file));
+	while (true) {
+		if (await exists(join(directory, ".git")) || await exists(join(directory, "package.json"))) return directory;
+		const parent = dirname(directory);
+		if (parent === directory) return directory;
+		directory = parent;
+	}
+}
+/** Nearest config wins; stop at the supplied workspace root or nearest package/Git root. */
+async function loadConfig(file, options = {}) {
+	let path = options.configPath && resolve(options.configPath);
+	if (!path) {
+		let directory = dirname(resolve(file));
+		const root = resolve(options.root ?? await projectRoot(file));
+		while (true) {
+			const candidates = [];
+			for (const name of [
+				"kotlin-format.json",
+				"kotlin-format.config.js",
+				"kotlin-format.config.mjs",
+				"kotlin-format.config.ts"
+			]) {
+				const candidate = join(directory, name);
+				if (await exists(candidate)) candidates.push(candidate);
+			}
+			if (candidates.length > 1) throw new Error(`${directory}: multiple kotlin-format configurations found`);
+			if (candidates.length) {
+				path = candidates[0];
+				break;
+			}
+			const parent = dirname(directory);
+			if (directory === root || parent === directory) break;
+			directory = parent;
+		}
+	}
+	if (!path) return {};
+	try {
+		const extension = extname(path);
+		if (![
+			".json",
+			".js",
+			".mjs",
+			".ts"
+		].includes(extension)) throw new Error("expected a .json, .js, .mjs or .ts config");
+		if (extension !== ".json" && options.allowCode === false) throw new Error("executable configuration requires a trusted workspace");
+		const source = await readFile(path, "utf8");
+		if (extension === ".json") return validateConfig(JSON.parse(source));
+		const url = pathToFileURL(path);
+		url.searchParams.set("version", createHash("sha256").update(source).digest("hex"));
+		const module = await import(url.href);
+		if ("module.exports" in module) throw new Error("CommonJS configuration is not supported; use ESM export default");
+		return validateConfig(module.default);
+	} catch (error) {
+		throw new Error(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function resolveOptions(config = {}) {
+	const style = config.style ?? "KOTLINLANG";
+	return {
+		style,
+		maxWidth: config.maxWidth ?? 100,
+		blockIndent: style === "KOTLINLANG" ? 4 : 2,
+		continuationIndent: style === "GOOGLE" ? 2 : 4,
+		trailingCommas: style === "META" ? "ONLY_ADD" : "COMPLETE",
+		removeUnusedImports: config.removeUnusedImports ?? true,
+		preserveLambdaBreaks: config.preserveLambdaBreaks ?? true
+	};
+}
+export { exists, loadConfig, projectRoot, resolveOptions, validateConfig };

package/dist/kotlin-format.d.mts

@@ -0,0 +1,18 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function tokenize(source: string): string;
+export declare function parseFile(source: string): string;
+export declare function parseScript(source: string): string;
+export declare function openDocument(source: string, script: boolean): number;
+export declare function editDocument(id: number, start: number, end: number, text: string): string;
+export declare function documentTree(id: number): string;
+export declare function documentSymbols(id: number): string;
+export declare function documentNavigationQuery(id: number, offset: number): string;
+export declare function documentExternalReference(id: number, offset: number): string;
+export declare function closeDocument(id: number): void;
+export declare function applyDocumentEdit(id: number, start: number, end: number, text: string): void;
+export declare function documentClassifications(id: number): NonNullable<unknown>;
+export declare function tokenLegend(): string;
+export declare function documentDefinitions(id: number, offset: number): NonNullable<unknown>;
+export declare function formatCode(source: string, style: string, maxWidth: number, script: boolean): string;
+export declare function formatWithOptions(source: string, maxWidth: number, blockIndent: number, continuationIndent: number, trailingCommas: string, removeUnusedImports: boolean, preserveLambdaBreaks: boolean, script: boolean): string;

package/dist/kotlin-format.import-object.mjs

@@ -0,0 +1,136 @@
+
+import * as d2FzbTpqcy1zdHJpbmc from './kotlin-format.js-builtins.mjs';
+
+const wasmJsTag = WebAssembly.JSTag;
+const wasmTag = wasmJsTag ?? new WebAssembly.Tag({ parameters: ['externref'] });
+
+// Placed here to give access to it from externals (js_code)
+let wasmExports;
+
+if (typeof process !== 'undefined' && process.release.name === 'node') {
+    function doNotUseRequire() {
+        throw new Error("Do not use top-level require. Prefer to use JS import or define your own require instead. Read more: https://kotl.in/r9txlt")
+    }
+
+    var require = new Proxy((function() {}), {
+        apply(target, thisArg, argumentsList) {
+            if (globalThis.require != null) {
+                return globalThis.require.apply(thisArg, argumentsList);
+            } else {
+                doNotUseRequire();
+            }
+        },
+        get(target, prop, receiver) {
+            if (globalThis.require != null) {
+                return Reflect.get(globalThis.require, prop);
+            } else {
+                doNotUseRequire();
+            }
+        },
+    });
+}
+
+export function setWasmExports(exports) {
+    wasmExports = exports;
+}
+
+const cachedJsObjects = new WeakMap();
+function getCachedJsObject(ref, ifNotCached) {
+    if (typeof ref !== 'object' && typeof ref !== 'function') return ifNotCached;
+    const cached = cachedJsObjects.get(ref);
+    if (cached !== void 0) return cached;
+    cachedJsObjects.set(ref, ifNotCached);
+    return ifNotCached;
+}
+
+const js_code = {
+    'kotlin.createJsError' : (message, cause) => new Error(message, { cause }),
+    'kotlin.wasm.internal.jsThrow' : wasmTag === wasmJsTag ? (e) => { throw e; } : () => {},
+    'kotlin.wasm.internal.getJsEmptyString' : () => '',
+    'kotlin.wasm.internal.externrefToString' : (ref) => String(ref),
+    'kotlin.wasm.internal.externrefEquals' : (lhs, rhs) => lhs === rhs,
+    'kotlin.wasm.internal.externrefHashCode' : 
+    (() => {
+    const dataView = new DataView(new ArrayBuffer(8));
+    function numberHashCode(obj) {
+        if ((obj | 0) === obj) {
+            return obj | 0;
+        } else {
+            dataView.setFloat64(0, obj, true);
+            return (dataView.getInt32(0, true) * 31 | 0) + dataView.getInt32(4, true) | 0;
+        }
+    }
+
+    const hashCodes = new WeakMap();
+    function getObjectHashCode(obj) {
+        const res = hashCodes.get(obj);
+        if (res === undefined) {
+            const POW_2_32 = 4294967296;
+            const hash = (Math.random() * POW_2_32) | 0;
+            hashCodes.set(obj, hash);
+            return hash;
+        }
+        return res;
+    }
+
+    function getStringHashCode(str) {
+        var hash = 0;
+        for (var i = 0; i < str.length; i++) {
+            var code  = str.charCodeAt(i);
+            hash  = (hash * 31 + code) | 0;
+        }
+        return hash;
+    }
+
+    return (obj) => {
+        if (obj == null) {
+            return 0;
+        }
+        switch (typeof obj) {
+            case "object":
+            case "function":
+                return getObjectHashCode(obj);
+            case "number":
+                return numberHashCode(obj);
+            case "boolean":
+                return obj ? 1231 : 1237;
+            default:
+                return getStringHashCode(String(obj)); 
+        }
+    }
+    })(),
+    'kotlin.wasm.internal.isNullish' : (ref) => ref == null,
+    'kotlin.wasm.internal.kotlinUIntToJsNumberUnsafe' : (x) => x >>> 0,
+    'kotlin.wasm.internal.getCachedJsObject_$external_fun' : (p0, p1) => getCachedJsObject(p0, p1),
+    'kotlin.wasm.internal.utoa32_$external_fun' : (p0) => String(p0),
+    'kotlin.wasm.internal.itoa32_$external_fun' : (p0) => String(p0),
+    'kotlin.js.stackPlaceHolder_js_code' : () => (''),
+    'kotlin.js.message_$external_prop_getter' : (_this) => _this.message,
+    'kotlin.js.name_$external_prop_setter' : (_this, v) => _this.name = v,
+    'kotlin.js.stack_$external_prop_getter' : (_this) => _this.stack,
+    'kotlin.js.kotlinException_$external_prop_getter' : (_this) => _this.kotlinException,
+    'kotlin.js.kotlinException_$external_prop_setter' : (_this, v) => _this.kotlinException = v,
+    'kotlin.js.JsError_$external_class_instanceof' : (x) => x instanceof Error,
+    'kotlin.random.initialSeed' : () => ((Math.random() * Math.pow(2, 32)) | 0),
+    'kotlin.wasm.internal.getJsClassName' : (jsKlass) => jsKlass.name,
+    'kotlin.wasm.internal.getConstructor' : (obj) => obj.constructor,
+    'li.songe.kotlin.writeSpan' : (data, offset, start, end, type, modifiers) => { data[offset] = start; data[offset + 1] = end; data[offset + 2] = type; data[offset + 3] = modifiers; },
+    'li.songe.kotlin.Int32Array_$external_fun' : (p0) => new Int32Array(p0)
+}
+
+const StringConstantsProxy = new Proxy({}, {
+  get(_, prop) { return prop; }
+});
+
+export { wasmTag as __TAG };
+
+export const importObject = {
+    js_code,
+    intrinsics: {
+        memory: new WebAssembly.Memory({ initial: 0 }),
+        tag: wasmTag
+    },
+    "'": StringConstantsProxy,
+    'wasm:js-string': d2FzbTpqcy1zdHJpbmc,
+};
+    

package/dist/kotlin-format.js-builtins.mjs

@@ -0,0 +1,52 @@
+export const length = (s) => s.length
+export const concat = (a, b) => a + b
+export const charCodeAt = (s, i) => s.charCodeAt(i >>> 0)
+export const substring = (s, start, end) => {
+    start >>>= 0;
+    end >>>= 0;
+    return s.substring(start, end);
+}
+
+export const compare = (a, b) => {
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+
+export const equals = (a, b) => a === b ? 1 : 0
+const moduleFromCharCodeArray = new WebAssembly.Module(new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x02, 0x5e,
+  0x77, 0x01, 0x60, 0x02, 0x64, 0x00, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01,
+  0x01, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x31, 0x36, 0x5f, 0x67, 0x65, 0x74,
+  0x00, 0x00, 0x0a, 0x0b, 0x01, 0x09, 0x00, 0x20, 0x00, 0x20, 0x01, 0xfb,
+  0x0d, 0x00, 0x0b, 0x00, 0x13, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x0c,
+  0x01, 0x00, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5f, 0x69, 0x31, 0x36
+]));
+const helpersFromCharCodeArray = new WebAssembly.Instance(moduleFromCharCodeArray).exports;
+
+export const fromCharCodeArray = (array, start, end) => {
+    start >>>= 0;
+    end >>>= 0;
+    let result = [];
+    for (let i = start; i < end; i++) {
+        result.push(String.fromCharCode(helpersFromCharCodeArray.a16_get(array, i)));
+    }
+    return result.join("");
+}
+
+const moduleIntoCharCode = new WebAssembly.Module(new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x02, 0x5e,
+  0x77, 0x01, 0x60, 0x03, 0x64, 0x00, 0x7f, 0x7f, 0x00, 0x03, 0x02, 0x01,
+  0x01, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x31, 0x36, 0x5f, 0x73, 0x65, 0x74,
+  0x00, 0x00, 0x0a, 0x0d, 0x01, 0x0b, 0x00, 0x20, 0x00, 0x20, 0x01, 0x20,
+  0x02, 0xfb, 0x0e, 0x00, 0x0b, 0x00, 0x13, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+  0x04, 0x0c, 0x01, 0x00, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5f, 0x69,
+  0x31, 0x36
+]));
+const helpersIntoCharCode = new WebAssembly.Instance(moduleIntoCharCode).exports;
+
+export const intoCharCodeArray = (s, array, start) => {
+    start >>>= 0;
+    for (let i = 0; i < s.length; i++) {
+      helpersIntoCharCode.a16_set(array, start + i, s.charCodeAt(i));
+    }
+    return s.length;
+}

package/dist/kotlin-format.mjs

@@ -0,0 +1,98 @@
+
+
+import { importObject, setWasmExports } from './kotlin-format.import-object.mjs'
+
+let wasmInstance;
+
+const wasmOptions = { builtins: ['js-string'], importedStringConstants: "'" }
+
+try {
+  if ((typeof process !== 'undefined') && (process.release.name === 'node')) {
+    const fs = await import(/* webpackIgnore: true */'node:fs');
+    const url = await import(/* webpackIgnore: true */'node:url');
+    const filepath = import.meta.resolve('./kotlin-format.wasm');
+    const wasmBuffer = fs.readFileSync(url.fileURLToPath(filepath));
+    const wasmModule = new WebAssembly.Module(wasmBuffer, wasmOptions);
+    wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+  } else if (typeof Deno !== 'undefined') {
+    const path = await import(/* webpackIgnore: true */'https://deno.land/std/path/mod.ts');
+    const binary = Deno.readFileSync(path.fromFileUrl(import.meta.resolve('./kotlin-format.wasm')));
+    const module = await WebAssembly.compile(binary, wasmOptions);
+    wasmInstance = await WebAssembly.instantiate(module, importObject);
+  } else if (
+    (typeof d8 !== 'undefined' // V8
+      || typeof inIon !== 'undefined' // SpiderMonkey
+      || typeof jscOptions !== 'undefined' // JavaScriptCore
+    )
+  ) {
+    const filepath = import.meta.url.replace(/\.mjs$/, '.wasm');
+    const wasmBuffer = read(filepath, 'binary');
+    const wasmModule = new WebAssembly.Module(wasmBuffer, wasmOptions);
+    wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+  } else {
+    wasmInstance = (await WebAssembly.instantiateStreaming(fetch(new URL('./kotlin-format.wasm',import.meta.url).href), importObject, wasmOptions)).instance;
+  }
+} catch (e) {
+  if (e instanceof WebAssembly.CompileError) {
+    let text = `Please make sure that your runtime environment supports the latest version of Wasm GC and Exception-Handling proposals.
+For more information, see https://kotl.in/wasm-help
+`;
+    if (typeof console !== "undefined" && console.error !== void 0) {
+      console.error(text);
+    } else {
+      const t = "\n" + text;
+      if (typeof console !== "undefined" && console.log !== void 0)
+        console.log(t);
+      else
+        print(t);
+    }
+  }
+  throw e;
+}
+
+const exports = wasmInstance.exports
+
+let memoryFirstTimeAccess = true;
+const memoryProxy = new Proxy(importObject.intrinsics.memory, {
+    get(target, prop, receiver) {
+        if (memoryFirstTimeAccess) {
+            memoryFirstTimeAccess = false;
+            console.error('Accessing `memory` via `wasmExports` is deprecated. Use `kotlin.wasm.unsafe.wasmMemory` or update dependencies. Read more: https://kotl.in/vr3szr');
+        }
+        return Reflect.get(target, prop);
+    }
+});
+const wasmExports = new Proxy(memoryProxy, {
+    get(target, prop, receiver) {
+        if (prop == 'memory') {
+            return target;
+        } else {
+            throw new Error('Accessing exports via `wasmExports` is no longer supported. Remove usages or update dependencies. Read more: https://kotl.in/vr3szr');
+        }
+    }
+});
+
+const wasmMemory = wasmExports.memory;
+export { wasmMemory as memory }
+
+export const {
+    tokenize,
+    parseFile,
+    parseScript,
+    openDocument,
+    editDocument,
+    documentTree,
+    documentSymbols,
+    documentNavigationQuery,
+    documentExternalReference,
+    closeDocument,
+    applyDocumentEdit,
+    documentClassifications,
+    tokenLegend,
+    documentDefinitions,
+    formatCode,
+    formatWithOptions
+} = exports
+
+setWasmExports(wasmExports);
+