harper.js 0.25.0 → 0.26.0

package/src/WorkerLinter/communication.test.ts

@@ -1,63 +0,0 @@
-import { expect, test } from 'vitest';
-import { deserializeArg, serializeArg } from './communication';
-import { Span } from 'wasm';
-import LocalLinter from '../LocalLinter';
-
-test('works with strings', async () => {
-	const start = 'This is a string';
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end).toBe(start);
-	expect(typeof end).toBe(typeof start);
-});
-
-test('works with false booleans', async () => {
-	const start = false;
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end).toBe(start);
-	expect(typeof end).toBe(typeof start);
-});
-
-test('works with true booleans', async () => {
-	const start = true;
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end).toBe(start);
-	expect(typeof end).toBe(typeof start);
-});
-
-test('works with numbers', async () => {
-	const start = 123;
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end).toBe(start);
-	expect(typeof end).toBe(typeof start);
-});
-
-test('works with Spans', async () => {
-	const start = Span.new(123, 321);
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end.start).toBe(start.start);
-	expect(end.len()).toBe(start.len());
-	expect(typeof end).toBe(typeof start);
-});
-
-test('works with Lints', async () => {
-	const linter = new LocalLinter();
-	const lints = await linter.lint('This is an test.');
-	const start = lints[0];
-
-	expect(start).not.toBeNull();
-
-	const end = await deserializeArg(structuredClone(await serializeArg(start)));
-
-	expect(end.message()).toBe(start.message());
-	expect(end.lint_kind()).toBe(start.lint_kind());
-});

package/src/WorkerLinter/communication.ts

@@ -1,111 +0,0 @@
-/** This module aims to define the communication protocol between the main thread and the worker.
- * Note that much of the complication here comes from the fact that we can't serialize function calls or referenced WebAssembly memory.*/
-
-import loadWasm from '../loadWasm';
-
-export type Type =
-	| 'string'
-	| 'number'
-	| 'boolean'
-	| 'Suggestion'
-	| 'Lint'
-	| 'Span'
-	| 'Array'
-	| 'undefined';
-
-/** Serializable argument to a procedure to be run on the web worker. */
-export type RequestArg = {
-	json: string;
-	type: Type;
-};
-
-export async function serialize(req: DeserializedRequest): Promise<SerializedRequest> {
-	return {
-		procName: req.procName,
-		args: await Promise.all(req.args.map(serializeArg))
-	};
-}
-
-export async function serializeArg(arg: any): Promise<RequestArg> {
-	const { Lint, Span, Suggestion } = await loadWasm();
-
-	if (Array.isArray(arg)) {
-		return { json: JSON.stringify(await Promise.all(arg.map(serializeArg))), type: 'Array' };
-	}
-
-	switch (typeof arg) {
-		case 'string':
-		case 'number':
-		case 'boolean':
-		case 'undefined':
-			// @ts-expect-error see the `Type` type.
-			return { json: JSON.stringify(arg), type: typeof arg };
-	}
-
-	if (arg.to_json != undefined) {
-		const json = arg.to_json();
-		let type: Type | undefined = undefined;
-
-		if (arg instanceof Lint) {
-			type = 'Lint';
-		} else if (arg instanceof Suggestion) {
-			type = 'Suggestion';
-		} else if (arg instanceof Span) {
-			type = 'Span';
-		}
-
-		if (type == undefined) {
-			throw new Error('Unhandled case');
-		}
-
-		return { json, type };
-	}
-
-	throw new Error('Unhandled case');
-}
-
-export async function deserializeArg(requestArg: RequestArg): Promise<any> {
-	const { Lint, Span, Suggestion } = await loadWasm();
-
-	switch (requestArg.type) {
-		case 'undefined':
-			return undefined;
-		case 'boolean':
-		case 'number':
-		case 'string':
-			return JSON.parse(requestArg.json);
-		case 'Suggestion':
-			return Suggestion.from_json(requestArg.json);
-		case 'Lint':
-			return Lint.from_json(requestArg.json);
-		case 'Span':
-			return Span.from_json(requestArg.json);
-		case 'Array':
-			return await Promise.all(JSON.parse(requestArg.json).map(deserializeArg));
-		default:
-			throw new Error(`Unhandled case: ${requestArg.type}`);
-	}
-}
-
-/** An object that is sent to the web worker to request work to be done. */
-export type SerializedRequest = {
-	/** The procedure to be executed. */
-	procName: string;
-	/** The arguments to the procedure */
-	args: RequestArg[];
-};
-
-/** An object that is received by the web worker to request work to be done. */
-export type DeserializedRequest = {
-	/** The procedure to be executed. */
-	procName: string;
-	/** The arguments to the procedure */
-	args: any[];
-};
-
-export async function deserialize(request: SerializedRequest): Promise<DeserializedRequest> {
-	return {
-		procName: request.procName,
-		args: await Promise.all(request.args.map(deserializeArg))
-	};
-}

package/src/WorkerLinter/index.ts

@@ -1,170 +0,0 @@
-import { DeserializedRequest, deserializeArg, serialize } from './communication';
-import type { Lint, Suggestion, Span } from 'wasm';
-import Linter from '../Linter';
-import Worker from './worker.js?worker&inline';
-import { getWasmUri } from '../loadWasm';
-import { LintConfig, LintOptions } from '../main';
-
-/** The data necessary to complete a request once the worker has responded. */
-type RequestItem = {
-	resolve: (item: unknown) => void;
-	reject: (item: unknown) => void;
-	request: DeserializedRequest;
-};
-
-/** A Linter that spins up a dedicated web worker to do processing on a separate thread.
- * Main benefit: this Linter will not block the event loop for large documents.
- *
- * NOTE: This class will not work properly in Node. In that case, just use `LocalLinter`. */
-export default class WorkerLinter implements Linter {
-	private worker;
-	private requestQueue: RequestItem[];
-	private working = true;
-
-	constructor() {
-		this.worker = new Worker();
-		this.requestQueue = [];
-
-		// Fires when the worker sends 'ready'.
-		this.worker.onmessage = () => {
-			this.setupMainEventListeners();
-
-			this.worker.postMessage(getWasmUri());
-
-			this.working = false;
-			this.submitRemainingRequests();
-		};
-	}
-
-	private setupMainEventListeners() {
-		this.worker.onmessage = (e: MessageEvent) => {
-			const { resolve } = this.requestQueue.shift()!;
-			deserializeArg(e.data).then((v) => {
-				resolve(v);
-
-				this.working = false;
-
-				this.submitRemainingRequests();
-			});
-		};
-
-		this.worker.onmessageerror = (e: MessageEvent) => {
-			const { reject } = this.requestQueue.shift()!;
-			reject(e.data);
-			this.working = false;
-
-			this.submitRemainingRequests();
-		};
-	}
-
-	setup(): Promise<void> {
-		return this.rpc('setup', []);
-	}
-
-	lint(text: string, options?: LintOptions): Promise<Lint[]> {
-		return this.rpc('lint', [text, options]);
-	}
-
-	applySuggestion(text: string, suggestion: Suggestion, span: Span): Promise<string> {
-		return this.rpc('applySuggestion', [text, suggestion, span]);
-	}
-
-	isLikelyEnglish(text: string): Promise<boolean> {
-		return this.rpc('isLikelyEnglish', [text]);
-	}
-
-	isolateEnglish(text: string): Promise<string> {
-		return this.rpc('isolateEnglish', [text]);
-	}
-
-	async getLintConfig(): Promise<LintConfig> {
-		return JSON.parse(await this.getLintConfigAsJSON());
-	}
-
-	setLintConfig(config: LintConfig): Promise<void> {
-		return this.setLintConfigWithJSON(JSON.stringify(config));
-	}
-
-	getLintConfigAsJSON(): Promise<string> {
-		return this.rpc('getLintConfigAsJSON', []);
-	}
-
-	setLintConfigWithJSON(config: string): Promise<void> {
-		return this.rpc('setLintConfigWithJSON', [config]);
-	}
-
-	toTitleCase(text: string): Promise<string> {
-		return this.rpc('toTitleCase', [text]);
-	}
-
-	getLintDescriptionsAsJSON(): Promise<string> {
-		return this.rpc('getLintDescriptionsAsJSON', []);
-	}
-
-	async getLintDescriptions(): Promise<Record<string, string>> {
-		return JSON.parse(await this.getLintDescriptionsAsJSON()) as Record<string, string>;
-	}
-
-	getDefaultLintConfigAsJSON(): Promise<string> {
-		return this.rpc('getDefaultLintConfigAsJSON', []);
-	}
-
-	async getDefaultLintConfig(): Promise<LintConfig> {
-		return JSON.parse(await this.getDefaultLintConfigAsJSON()) as LintConfig;
-	}
-
-	async ignoreLint(lint: Lint): Promise<void> {
-		return this.rpc('ignoreLint', [lint]);
-	}
-
-	async exportIgnoredLints(): Promise<string> {
-		return this.rpc('exportIgnoredLints', []);
-	}
-
-	async importIgnoredLints(json: string): Promise<void> {
-		return this.rpc('importIgnoredLints', [json]);
-	}
-
-	async clearIgnoredLints(): Promise<void> {
-		return this.rpc('clearIgnoredLints', []);
-	}
-
-	async importWords(words: string[]): Promise<void> {
-		return this.rpc('importWords', [words]);
-	}
-
-	async exportWords(): Promise<string[]> {
-		return this.rpc('exportWords', []);
-	}
-
-	/** Run a procedure on the remote worker. */
-	private async rpc(procName: string, args: any[]): Promise<any> {
-		const promise = new Promise((resolve, reject) => {
-			this.requestQueue.push({
-				resolve,
-				reject,
-				request: { procName, args }
-			});
-
-			this.submitRemainingRequests();
-		});
-
-		return promise;
-	}
-
-	private async submitRemainingRequests() {
-		if (this.working) {
-			return;
-		}
-
-		this.working = true;
-
-		if (this.requestQueue.length > 0) {
-			const { request } = this.requestQueue[0];
-
-			this.worker.postMessage(await serialize(request));
-		} else {
-			this.working = false;
-		}
-	}
-}

package/src/WorkerLinter/worker.js

@@ -1,24 +0,0 @@
-import { setWasmUri } from '../loadWasm';
-import LocalLinter from '../LocalLinter';
-import { deserialize, serializeArg } from './communication';
-
-const linter = new LocalLinter();
-
-/** @param {SerializedRequest} v  */
-async function processRequest(v) {
-	const { procName, args } = await deserialize(v);
-
-	let res = await linter[procName](...args);
-	postMessage(await serializeArg(res));
-}
-
-self.onmessage = function (e) {
-	setWasmUri(e.data);
-
-	self.onmessage = function (e) {
-		processRequest(e.data);
-	};
-};
-
-// Notify the main thread that we are ready
-postMessage('ready');

package/src/loadWasm.ts

@@ -1,26 +0,0 @@
-// @ts-expect-error because this virtual module hasn't been added to a `d.ts` file.
-import wasmUri from 'virtual:wasm';
-
-let curWasmUri = wasmUri;
-
-/** Get the currently set data URI for the WebAssembly module.
- * I'm not a huge of the singleton, but we're swapping out same data, just from a different source, so the state doesn't meaningfully change. */
-export function getWasmUri(): string {
-	return curWasmUri;
-}
-
-/** Set the data URI for the WebAssembly module. */
-export function setWasmUri(uri: string) {
-	curWasmUri = uri;
-}
-
-/** Load the WebAssembly manually and dynamically, making sure to set up infrastructure.
- * You can use an optional data URL for the WebAssembly file if the module is being loaded from a Web Worker.
- * */
-export default async function loadWasm() {
-	const wasm = await import('wasm');
-	// @ts-ignore
-	await wasm.default({ module_or_path: getWasmUri() });
-
-	return wasm;
-}

package/src/main.ts

@@ -1,18 +0,0 @@
-import type { Lint, Span, Suggestion } from 'wasm';
-import { SuggestionKind } from 'wasm';
-import Linter from './Linter';
-import LocalLinter from './LocalLinter';
-import WorkerLinter from './WorkerLinter';
-
-export { LocalLinter, WorkerLinter, SuggestionKind };
-export type { Linter, Lint, Span, Suggestion };
-
-/** A linting rule configuration dependent on upstream Harper's available rules.
- * This is a record, since you shouldn't hard-code the existence of any particular rules and should generalize based on this struct. */
-export type LintConfig = Record<string, boolean | undefined>;
-
-/** The option used to configure the parser for an individual linting operation. */
-export type LintOptions = {
-	/** The markup language that is being passed. Defaults to `markdown`. */
-	language?: 'plaintext' | 'markdown';
-};

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2020",
-		"useDefineForClassFields": true,
-		"module": "ESNext",
-		"lib": ["ES2020", "DOM", "DOM.Iterable"],
-		"skipLibCheck": true,
-		/* Bundler mode */
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"isolatedModules": true,
-		"moduleDetection": "force",
-		"noEmit": true,
-		/* Linting */
-		"strict": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"noFallthroughCasesInSwitch": true,
-		"types": ["vite/client"],
-		"paths": {
-			"wasm": ["../../harper-wasm/pkg"]
-		}
-	},
-	"include": ["src"]
-}

package/vite.config.js

@@ -1,63 +0,0 @@
-import { resolve } from 'path';
-import dts from 'vite-plugin-dts';
-import { defineConfig } from 'vite';
-import virtual from 'vite-plugin-virtual';
-import fs from 'fs';
-
-function fileAsObject(path) {
-	let content = fs.readFileSync(path);
-	return JSON.parse(content);
-}
-
-export default defineConfig({
-	build: {
-		lib: {
-			entry: resolve(__dirname, 'src/main.ts'),
-			fileName: `harper`,
-			name: 'harper',
-			formats: ['es']
-		},
-		rollupOptions: {
-			output: {
-				inlineDynamicImports: true
-			}
-		}
-	},
-	base: './',
-	plugins: [
-		dts({
-			...fileAsObject('./api-extractor.json'),
-			rollupTypes: true,
-			tsconfigPath: './tsconfig.json'
-		}),
-		virtual({
-			'virtual:wasm': `import wasmUri from 'wasm/harper_wasm_bg.wasm?inline'; export default wasmUri`
-		})
-	],
-	worker: {
-		plugins: [
-			virtual({
-				'virtual:wasm': `export default ''`
-			})
-		],
-		format: 'es',
-		rollupOptions: {
-			output: {
-				inlineDynamicImports: true
-			}
-		}
-	},
-	server: {
-		fs: {
-			allow: ['../../harper-wasm/pkg']
-		}
-	},
-	test: {
-		browser: {
-			provider: 'playwright',
-			enabled: true,
-			headless: true
-		}
-	},
-	assetsInclude: ['**/*.wasm']
-});