Offline, privacy-first grammar checker. Fast, open-source, Rust-powered
import { invoke } from '@tauri-apps/api/core';
import { disable, enable, isEnabled } from '@tauri-apps/plugin-autostart';
import type {
Dialect,
Lint,
LintConfig,
Linter,
LocalLinter as LocalLinterType,
StructuredLintConfig,
} from 'harper.js';
type RustDialect = 'American' | 'British' | 'Australian' | 'Canadian' | 'Indian';
const DialectValue = {
American: 0,
British: 1,
Australian: 2,
Canadian: 3,
Indian: 4,
} as const;
const ACCESSIBILITY_PERMISSION_TIMEOUT_MS = 6_000;
let configLinterPromise: Promise<LocalLinterType> | null = null;
function getConfigLinter(): Promise<LocalLinterType> {
configLinterPromise ??= Promise.all([
import('harper.js'),
import('harper.js/slimBinaryInlined'),
]).then(
([{ LocalLinter }, { slimBinaryInlined }]) => new LocalLinter({ binary: slimBinaryInlined }),
);
return configLinterPromise;
}
export interface Integration {
bundle_id: string;
enabled: boolean;
display_name: string;
}
export interface AppSearchResult {
name: string;
bundle_id: string;
}
export type AccessibilityPermissionStatus = 'Granted' | 'NotGranted' | 'Unsupported';
/** Serializable Rust updater outcome; an installed update may still require a restart. */
export interface UpdateResult {
status: 'up-to-date' | 'updated' | 'error';
currentVersion: string | null;
latestVersion: string | null;
message: string;
error: string | null;
}
/** Provides an easy-to-use interface for interacting with the main Rust Tauri process.
* Relevant because that is where the canonical state is stored. */
export class Client {
static async getLintConfig(): Promise<LintConfig> {
return await invoke<LintConfig>('get_lint_config');
}
static async getDefaultLintConfig(): Promise<LintConfig> {
const configLinter = await getConfigLinter();
return JSON.parse(await configLinter.getDefaultLintConfigAsJSON()) as LintConfig;
}
static async getStructuredLintConfig(): Promise<StructuredLintConfig> {
const configLinter = await getConfigLinter();
await configLinter.setLintConfigWithJSON(JSON.stringify(await Client.getLintConfig()));
return JSON.parse(await configLinter.getStructuredLintConfigJSON()) as StructuredLintConfig;
}
static async getDialect(): Promise<Dialect> {
return rustDialectToDialect(await invoke<RustDialect>('get_dialect'));
}
static async setDialect(dialect: Dialect): Promise<void> {
await invoke('set_dialect', { dialect: dialectToRustDialect(dialect) });
}
static async getDebounceMs(): Promise<number> {
return await invoke<number>('get_debounce_ms');
}
static async setDebounceMs(debounceMs: number): Promise<void> {
await invoke('set_debounce_ms', { debounceMs });
}
/** Check if the app is configured to auto update. */
static async getAutoUpdate(): Promise<boolean> {
return await invoke<boolean>('get_auto_update');
}
/** Configure the app to auto update. */
static async setAutoUpdate(autoUpdate: boolean): Promise<void> {
await invoke('set_auto_update', { autoUpdate });
}
static async getCurrentVersion(): Promise<string> {
return await invoke<string>('get_current_version');
}
static async getLatestVersion(): Promise<string> {
return await invoke<string>('get_latest_version');
}
static async updateToLatest(): Promise<UpdateResult> {
return await invoke<UpdateResult>('update_to_latest');
}
static async getOnboardingCompleted(): Promise<boolean> {
return await invoke<boolean>('get_onboarding_completed');
}
static async setOnboardingCompleted(onboardingCompleted: boolean): Promise<void> {
await invoke('set_onboarding_completed', { onboardingCompleted });
}
static async getLaunchAtStartup(): Promise<boolean> {
return await isEnabled();
}
static async setLaunchAtStartup(enabled: boolean): Promise<void> {
if (enabled) {
await enable();
} else {
await disable();
}
}
static async setLintConfig(lintConfig: LintConfig): Promise<void> {
await invoke('set_lint_config', { lintConfig });
}
static async getDictionary(): Promise<string[]> {
return await invoke<string[]>('get_dictionary');
}
static async setDictionary(words: string[]): Promise<void> {
await invoke('set_dictionary', { words });
}
static async disableRule(ruleName: string): Promise<LintConfig> {
const lintConfig = await Client.getLintConfig();
lintConfig[ruleName] = false;
await Client.setLintConfig(lintConfig);
return lintConfig;
}
static async ignoreLint(linter: Linter, source: string, lint: Lint): Promise<void> {
await linter.ignoreLint(source, lint);
const ignoredLints = await linter.exportIgnoredLints();
await invoke('ignore_lint', { ignoredLints });
}
static async addToDictionary(word: string): Promise<void> {
await invoke('add_to_dictionary', { word });
}
static async getIntegrations(): Promise<Integration[]> {
return await invoke<Integration[]>('get_integrations');
}
static async getAutoEnableNewApps(): Promise<boolean> {
return await invoke<boolean>('get_auto_enable_new_apps');
}
static async setAutoEnableNewApps(autoEnableNewApps: boolean): Promise<void> {
await invoke('set_auto_enable_new_apps', { autoEnableNewApps });
}
static async addIntegration(bundleId: string): Promise<void> {
await invoke('add_integration', { bundleId });
}
static async removeIntegration(bundleId: string): Promise<void> {
await invoke('remove_integration', { bundleId });
}
static async setIntegrationEnabled(bundleId: string, enabled: boolean): Promise<void> {
await invoke('set_integration_enabled', { bundleId, enabled });
}
static async getApplicationIconDataUrl(bundleId: string): Promise<string> {
return await invoke<string>('get_application_icon_data_url', { bundleId });
}
static async searchApps(query: string): Promise<AppSearchResult[]> {
return await invoke<AppSearchResult[]>('search_apps', { query });
}
static async launchApp(bundleId: string): Promise<void> {
await invoke('launch_app', { bundleId });
}
static async getAccessibilityPermissionStatus(): Promise<AccessibilityPermissionStatus> {
return await withTimeout(
invoke<AccessibilityPermissionStatus>('get_accessibility_permission_status'),
ACCESSIBILITY_PERMISSION_TIMEOUT_MS,
'Accessibility permission check timed out',
);
}
static async requestAccessibilityPermission(): Promise<AccessibilityPermissionStatus> {
return await withTimeout(
invoke<AccessibilityPermissionStatus>('request_accessibility_permission'),
ACCESSIBILITY_PERMISSION_TIMEOUT_MS,
'Accessibility permission request timed out',
);
}
static async startHighlighterService(): Promise<boolean> {
return await invoke<boolean>('start_highlighter_service');
}
static async stopHighlighterService(): Promise<boolean> {
return await invoke<boolean>('stop_highlighter_service');
}
}
async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
let timeoutId: ReturnType<typeof setTimeout> | undefined;
const timeout = new Promise<never>((_, reject) => {
timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
});
try {
return await Promise.race([promise, timeout]);
} finally {
if (timeoutId) {
clearTimeout(timeoutId);
}
}
}
function rustDialectToDialect(dialect: RustDialect): Dialect {
switch (dialect) {
case 'British':
return DialectValue.British as Dialect;
case 'Australian':
return DialectValue.Australian as Dialect;
case 'Canadian':
return DialectValue.Canadian as Dialect;
case 'Indian':
return DialectValue.Indian as Dialect;
default:
return DialectValue.American as Dialect;
}
}
function dialectToRustDialect(dialect: Dialect): RustDialect {
switch (dialect) {
case DialectValue.British:
return 'British';
case DialectValue.Australian:
return 'Australian';
case DialectValue.Canadian:
return 'Canadian';
case DialectValue.Indian:
return 'Indian';
default:
return 'American';
}
}