@doki-land/nifty 0.1.0 → 0.1.2

package/src/cli/upload.ts

@@ -29,11 +29,11 @@ type GithubRelease = {
     id: number;
 };
 
-export async function runUpload(argv: string[]): Promise<void> {
+export async function runUpload(argv: string[]): Promise < void> {
     await uploadFromOptions(parseUploadArgs(argv));
 }
 
-export async function uploadFromOptions(options: UploadOptions): Promise<void> {
+export async function uploadFromOptions(options: UploadOptions): Promise < void> {
     if (options.githubAction) {
         applyGithubActionDefaults(options);
     }
@@ -83,52 +83,52 @@ function parseUploadArgs(argv: string[]): UploadOptions {
 
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if (arg === "--release") options.release = true;
-        else if (arg === "--pages") options.pages = true;
-        else if (arg === "--both") options.both = true;
-        else if (arg === "-d" || arg === "--dir") options.dir = argv[++i];
+        if (arg === "--release")options.release = true;
+        else if (arg === "--pages")options.pages = true;
+        else if (arg === "--both")options.both = true;
+        else if (arg === "-d" || arg === "--dir")options.dir = argv[++i];
         else if (arg === "-h" || arg === "--help") {
             printUploadHelp();
             process.exit(0);
         }
-        else if (arg === "-t" || arg === "--tag") options.tag = argv[++i];
-        else if (arg === "--repo") options.repo = argv[++i];
-        else if (arg === "--token") options.token = argv[++i];
-        else if (arg === "--name") options.name = argv[++i];
-        else if (arg === "--notes") options.notes = argv[++i];
-        else if (arg === "--notes-file") options.notesFile = argv[++i];
-        else if (arg === "--draft") options.draft = true;
-        else if (arg === "--no-generate-notes") options.generateNotes = false;
-        else if (arg === "--github-action") options.githubAction = true;
-        else if (arg === "-C" || arg === "--cwd") options.cwd = argv[++i];
+        else if (arg === "-t" || arg === "--tag")options.tag = argv[++i];
+        else if (arg === "--repo")options.repo = argv[++i];
+        else if (arg === "--token")options.token = argv[++i];
+        else if (arg === "--name")options.name = argv[++i];
+        else if (arg === "--notes")options.notes = argv[++i];
+        else if (arg === "--notes-file")options.notesFile = argv[++i];
+        else if (arg === "--draft")options.draft = true;
+        else if (arg === "--no-generate-notes")options.generateNotes = false;
+        else if (arg === "--github-action")options.githubAction = true;
+        else if (arg === "-C" || arg === "--cwd")options.cwd = argv[++i];
     }
 
     return options;
 }
 
 function parseTarget(options: UploadOptions): "release" | "pages" | "both" {
-    if (options.both) return "both";
-    if (options.pages) return "pages";
-    if (options.release) return "release";
+    if (options.both)return "both";
+    if (options.pages)return "pages";
+    if (options.release)return "release";
     throw new Error("specify --release, --pages, or --both");
 }
 
 function applyGithubActionDefaults(options: UploadOptions): void {
-    options.token ??= process.env.GITHUB_TOKEN;
-    options.repo ??= process.env.GITHUB_REPOSITORY;
-    options.tag ??= process.env.GITHUB_REF_NAME;
-    options.cwd ??= process.env.GITHUB_WORKSPACE;
+    options.token??= process.env.GITHUB_TOKEN;
+    options.repo??= process.env.GITHUB_REPOSITORY;
+    options.tag??= process.env.GITHUB_REF_NAME;
+    options.cwd??= process.env.GITHUB_WORKSPACE;
 }
 
 async function resolveNotes(
     options: UploadOptions,
     repoRoot: string,
     tag: string,
-    native: ReturnType<typeof loadNiftyNative>,
-): Promise<string> {
-    if (options.notes) return options.notes;
-    if (options.notesFile) return readFileSync(options.notesFile, "utf8");
-    if (!options.generateNotes) return "";
+    native: ReturnType < typeof loadNiftyNative > ,
+): Promise < string> {
+    if (options.notes)return options.notes;
+    if (options.notesFile)return readFileSync(options.notesFile, "utf8");
+    if (!options.generateNotes)return "";
     try {
         const range = native.git["resolve-range"](repoRoot, tag.replace(/^v/, ""), undefined, tag);
         const commits = native.git["collect-commits"](repoRoot, range["from-ref"], range["to-ref"]);
@@ -144,8 +144,8 @@ async function uploadReleaseAssets(
     tag: string,
     options: UploadOptions,
     notes: string,
-): Promise<void> {
-    const [owner, name] = splitRepo(repo);
+): Promise < void> {
+    const[owner, name] = splitRepo(repo);
     let release = await apiReleaseByTag(owner, name, tag, token);
     if (!release) {
         release = await apiCreateRelease(owner, name, tag, options.name ?? tag, notes, options.draft, token);
@@ -178,8 +178,8 @@ Options:
 `);
 }
 
-async function deployGithubPages(repo: string, token: string, dir: string): Promise<void> {
-    const [owner, name] = splitRepo(repo);
+async function deployGithubPages(repo: string, token: string, dir: string): Promise < void> {
+    const[owner, name] = splitRepo(repo);
     const source = resolve(dir);
     const work = mkdtempSync(join(tmpdir(), "nifty-pages-"));
     cpSync(source, work, { recursive: true });
@@ -226,7 +226,7 @@ function splitRepo(repo: string): [string, string] {
     if (parts.length !== 2 || !parts[0] || !parts[1]) {
         throw new Error(`invalid repo ${repo}, expected owner/name`);
     }
-    return [parts[0], parts[1]];
+    return[parts[0], parts[1]];
 }
 
 async function apiReleaseByTag(
@@ -234,16 +234,16 @@ async function apiReleaseByTag(
     name: string,
     tag: string,
     token: string,
-): Promise<GithubRelease | null> {
+): Promise < GithubRelease | null > {
     const response = await fetch(
         `https://api.github.com/repos/${owner}/${name}/releases/tags/${encodeURIComponent(tag)}`,
         { headers: githubHeaders(token) },
     );
-    if (response.status === 404) return null;
+    if (response.status === 404)return null;
     if (!response.ok) {
         throw new Error(`GitHub API ${response.status}: ${await response.text()}`);
     }
-    return (await response.json()) as GithubRelease;
+    return(await response.json())as GithubRelease;
 }
 
 async function apiCreateRelease(
@@ -254,7 +254,7 @@ async function apiCreateRelease(
     body: string,
     draft: boolean,
     token: string,
-): Promise<GithubRelease> {
+): Promise < GithubRelease> {
     const response = await fetch(`https://api.github.com/repos/${owner}/${name}/releases`, {
         method: "POST",
         headers: { ...githubHeaders(token), "Content-Type": "application/json" },
@@ -263,7 +263,7 @@ async function apiCreateRelease(
     if (!response.ok) {
         throw new Error(`GitHub API ${response.status}: ${await response.text()}`);
     }
-    return (await response.json()) as GithubRelease;
+    return(await response.json())as GithubRelease;
 }
 
 async function apiUploadAsset(
@@ -273,7 +273,7 @@ async function apiUploadAsset(
     assetName: string,
     filePath: string,
     token: string,
-): Promise<void> {
+): Promise < void> {
     const url = `https://uploads.github.com/repos/${owner}/${name}/releases/${releaseId}/assets?name=${encodeURIComponent(assetName)}`;
     const body = readFileSync(filePath);
     const response = await fetch(url, {
@@ -296,7 +296,7 @@ async function apiUploadAsset(
     throw new Error(`GitHub upload ${response.status}: ${text}`);
 }
 
-function githubHeaders(token: string): Record<string, string> {
+function githubHeaders(token: string): Record < string, string > {
     return {
         Accept: "application/vnd.github+json",
         Authorization: `Bearer ${token}`,

package/src/cli/workspace.ts

@@ -16,10 +16,10 @@ export type PackageManifest = {
     name: string;
     version: string;
     private?: boolean;
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    optionalDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
+    dependencies?: Record < string, string > ;
+    devDependencies?: Record < string, string > ;
+    optionalDependencies?: Record < string, string > ;
+    peerDependencies?: Record < string, string > ;
 };
 
 const DEPENDENCY_FIELDS = [
@@ -27,7 +27,7 @@ const DEPENDENCY_FIELDS = [
     "devDependencies",
     "optionalDependencies",
     "peerDependencies",
-] as const;
+]as const;
 
 export function findWorkspaceRoot(cwd: string): string {
     const layout = detectProjectLayout(cwd);
@@ -45,7 +45,7 @@ export function findWorkspaceRoot(cwd: string): string {
 export function listWorkspacePackages(root: string): WorkspacePackage[] {
     const packagesDir = join(root, "projects", "packages");
     if (!existsSync(packagesDir)) {
-        return [];
+        return[];
     }
 
     const packages: WorkspacePackage[] = [];
@@ -57,7 +57,7 @@ export function listWorkspacePackages(root: string): WorkspacePackage[] {
         if (!existsSync(manifestPath)) {
             continue;
         }
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as PackageManifest;
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"))as PackageManifest;
         if (!manifest.name || !manifest.version) {
             throw new Error(`package.json missing name or version: ${manifestPath}`);
         }
@@ -76,15 +76,15 @@ export function listWorkspacePackages(root: string): WorkspacePackage[] {
 
 export function collectInternalDependencyNames(
     pkg: WorkspacePackage,
-    byName: Map<string, WorkspacePackage>,
-): Set<string> {
-    const deps = new Set<string>();
+    byName: Map < string, WorkspacePackage > ,
+): Set < string> {
+    const deps = new Set < string> ();
     for (const field of DEPENDENCY_FIELDS) {
         const entries = pkg.manifest[field];
         if (!entries) {
             continue;
         }
-        for (const [depName, spec] of Object.entries(entries)) {
+        for (const[depName, spec]of Object.entries(entries)) {
             if (byName.has(depName)) {
                 deps.add(depName);
                 continue;
@@ -101,7 +101,7 @@ export function collectInternalDependencyNames(
 function resolveWorkspaceDependencyName(
     spec: string,
     packageDir: string,
-    byName: Map<string, WorkspacePackage>,
+    byName: Map < string, WorkspacePackage > ,
 ): string | undefined {
     if (spec.startsWith("workspace:")) {
         return undefined;
@@ -119,6 +119,6 @@ function resolveWorkspaceDependencyName(
     if (!existsSync(manifestPath)) {
         return undefined;
     }
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as PackageManifest;
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"))as PackageManifest;
     return manifest.name;
 }

package/src/config/authorMap.ts

@@ -13,12 +13,8 @@ export function resolveAuthorMapPath(config: NiftyConfig, repoRoot: string): str
 }
 
 /** Load author map file contents for native helpers expecting JSON text. */
-export function loadAuthorMapJson(repoRoot: string, authorMapPath?: string): string {
-    const abs = authorMapPath
-        ? isAbsolute(authorMapPath)
-            ? authorMapPath
-            : join(repoRoot, authorMapPath)
-        : resolveAuthorMapPath({}, repoRoot);
+export function loadAuthorMapJson(repoRoot: string, authorMapPath?: string) : string {
+    const abs = authorMapPath ? isAbsolute(authorMapPath) ? authorMapPath : join(repoRoot, authorMapPath) : resolveAuthorMapPath({ }, repoRoot);
     if (!existsSync(abs)) {
         return "{}";
     }

package/src/config/defineConfig.ts

@@ -3,10 +3,10 @@ import type { NiftyConfig, NiftyConfigEnv } from "./types.js";
 /** Type-safe helper for `nifty.config.ts` / `nifty.config.js`. */
 export function defineConfig(config: NiftyConfig): NiftyConfig;
 export function defineConfig(
-    config: (env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>,
-): (env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>;
+    config: (env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> ,
+): (env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> ;
 export function defineConfig(
-    config: NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>),
-): NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>) {
+    config: NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> ),
+): NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> ) {
     return config;
 }

package/src/config/detectProject.ts

@@ -162,7 +162,7 @@ export function detectProjectLayout(cwd = process.cwd()): ProjectLayout {
 
 /** Discover npm package directories for hybrid monorepos. */
 export function discoverPackageDirs(layout: ProjectLayout): string[] {
-    const roots = new Set<string>();
+    const roots = new Set < string> ();
 
     if (layout.npmWorkspaceRoot) {
         roots.add(layout.npmWorkspaceRoot);
@@ -185,5 +185,5 @@ export function discoverPackageDirs(layout: ProjectLayout): string[] {
         }
     }
 
-    return [...roots];
+    return[...roots];
 }

package/src/config/formatPresets.ts

@@ -23,7 +23,7 @@ const NIFTY_PRESET_INCLUDES = [
     "projects/dashboard/**",
     "package.json",
     "nifty.config.ts",
-] as const;
+]as const;
 
 /** VMZ hybrid monorepo — JS/TS surfaces only, never whole-repo walk. */
 const VMZ_INCLUDES = [
@@ -37,9 +37,9 @@ const VMZ_INCLUDES = [
     "packages/homepage/**",
     "package.json",
     "nifty.config.ts",
-] as const;
+]as const;
 
-const PRESET_INCLUDES: Record<NiftyFormatPreset, readonly string[] | undefined> = {
+const PRESET_INCLUDES: Record < NiftyFormatPreset, readonly string[] | undefined > = {
     default: undefined,
     nifty: NIFTY_PRESET_INCLUDES,
     "npm-tools": NIFTY_PRESET_INCLUDES,

package/src/config/loadConfig.ts

@@ -12,7 +12,7 @@ export type LoadConfigOptions = {
     /** When set, skip searching and load this file directly. */
     configFile?: string;
     /** Passed to functional configs: `export default defineConfig(({ mode }) => ...)`. */
-    env?: Partial<NiftyConfigEnv>;
+    env?: Partial < NiftyConfigEnv> ;
     /**
      * When true (default), write `nifty.config.ts` at the detected project root if missing.
      * Set false for `--dry-run` so commands only report what would happen.
@@ -63,7 +63,7 @@ export function defaultConfigPath(cwd = process.cwd()): string {
 }
 
 /** Warn and optionally create a default config when none exists. */
-export function ensureConfigFile(options: { cwd?: string; create?: boolean } = {}): string | undefined {
+export function ensureConfigFile(options: { cwd?: string; create?: boolean } = { }): string | undefined {
     const cwd = options.cwd ?? process.cwd();
     const existing = findConfigFile(cwd);
     if (existing) {
@@ -83,12 +83,12 @@ export function ensureConfigFile(options: { cwd?: string; create?: boolean } = {
 
 function normalizeExport(raw: unknown): NiftyConfigExport {
     if (raw && typeof raw === "object" && "default" in raw) {
-        return (raw as { default: NiftyConfigExport }).default;
+        return(raw as { default: NiftyConfigExport }).default;
     }
     return raw as NiftyConfigExport;
 }
 
-async function resolveExport(exported: NiftyConfigExport, env: NiftyConfigEnv): Promise<NiftyConfig> {
+async function resolveExport(exported: NiftyConfigExport, env: NiftyConfigEnv): Promise < NiftyConfig> {
     if (typeof exported === "function") {
         return await exported(env);
     }
@@ -96,7 +96,7 @@ async function resolveExport(exported: NiftyConfigExport, env: NiftyConfigEnv):
 }
 
 /** Load `nifty.config.ts/js`, creating a default file at the project root when missing. */
-export async function loadConfig(options: LoadConfigOptions = {}): Promise<LoadedNiftyConfig> {
+export async function loadConfig(options: LoadConfigOptions = { }): Promise < LoadedNiftyConfig> {
     const cwd = options.cwd ?? process.cwd();
     let configFile = options.configFile ?? findConfigFile(cwd);
     let created = false;
@@ -106,11 +106,11 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Loade
         created = Boolean(configFile);
     } else if (!configFile) {
         ensureConfigFile({ cwd, create: false });
-        return { config: {} };
+        return { config: { } };
     }
 
     if (!configFile) {
-        return { config: {} };
+        return { config: { } };
     }
 
     const env: NiftyConfigEnv = { ...DEFAULT_ENV(cwd), ...options.env };

package/src/config/trustPayload.ts

@@ -4,11 +4,11 @@ import type { NiftyConfig } from "./types.js";
 export function trustPayloadFromConfig(config: NiftyConfig) {
     const npm = config.trust?.npm;
     if (!npm) {
-        return {};
+        return { };
     }
     return {
-        ...(npm.repo ? { trustRepo: npm.repo } : {}),
-        ...(npm.file ? { trustFile: npm.file } : {}),
-        ...(npm.environment ? { trustEnvironment: npm.environment } : {}),
+        ...(npm.repo ? { trustRepo: npm.repo } : { }),
+        ...(npm.file ? { trustFile: npm.file } : { }),
+        ...(npm.environment ? { trustEnvironment: npm.environment } : { }),
     };
 }

package/src/config/types.ts

@@ -84,7 +84,7 @@ export type NiftyConfig = {
     };
     /** Rule-based lint configuration. */
     lint?: {
-        rules?: Array<{
+        rules?: Array < {
             id: string;
             enabled?: boolean;
             severity?: "error" | "warning" | "info";
@@ -94,7 +94,7 @@ export type NiftyConfig = {
     format?: NiftyFormatConfig;
 };
 
-export type NiftyConfigExport = NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>);
+export type NiftyConfigExport = NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> );
 
 export type NiftyConfigEnv = {
     mode: string;
@@ -108,4 +108,4 @@ export const CONFIG_FILE_NAMES = [
     "nifty.config.js",
     "nifty.config.mjs",
     "nifty.config.cjs",
-] as const;
+]as const;

package/src/git.ts

@@ -11,7 +11,7 @@ export type ResolveRangeOptions = {
  * Read-only git repository helpers (gix via Node-API, no `git` subprocess).
  */
 export class Git {
-    constructor(private readonly wasm: GitExports) {}
+    constructor(private readonly wasm: GitExports) { }
 
     static open(): Git {
         const native = loadNiftyNative();
@@ -36,7 +36,7 @@ export class Git {
         return this.wasm["format-tag-list"](repoRoot);
     }
 
-    resolveRange(repoRoot: string, options: ResolveRangeOptions = {}): RangeInfo {
+    resolveRange(repoRoot: string, options: ResolveRangeOptions = { }): RangeInfo {
         return mapRangeInfo(
             this.wasm["resolve-range"](repoRoot, options.version, options.fromRef, options.toRef),
         );

package/src/github.ts

@@ -3,7 +3,7 @@ import type { GithubAuthor } from "./types.js";
 const USER_AGENT = "nifty-github";
 const ACCEPT = "application/vnd.github+json";
 
-function parseUserJson(body: Record<string, unknown>, fallbackLogin?: string): GithubAuthor {
+function parseUserJson(body: Record < string, unknown > , fallbackLogin?: string) : GithubAuthor {
     const id = typeof body.id === "number" ? BigInt(body.id) : undefined;
     const login = typeof body.login === "string" ? body.login : fallbackLogin;
     if (id === undefined && login === undefined) {
@@ -12,8 +12,8 @@ function parseUserJson(body: Record<string, unknown>, fallbackLogin?: string): G
     return { id, login };
 }
 
-async function getJson(url: string, token?: string): Promise<Record<string, unknown>> {
-    const headers: Record<string, string> = {
+async function getJson(url: string, token?: string) : Promise < Record < string, unknown>> {
+    const headers: Record < string, string > = {
         Accept: ACCEPT,
         "User-Agent": USER_AGENT,
     };
@@ -27,7 +27,7 @@ async function getJson(url: string, token?: string): Promise<Record<string, unkn
     if (!response.ok) {
         throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
     }
-    return (await response.json()) as Record<string, unknown>;
+    return(await response.json())as Record < string, unknown > ;
 }
 
 function parseNoreplyEmail(email: string): GithubAuthor | undefined {
@@ -37,7 +37,7 @@ function parseNoreplyEmail(email: string): GithubAuthor | undefined {
     if (!lower.endsWith(suffix)) {
         return undefined;
     }
-    const local = trimmed.slice(0, -suffix.length);
+    const local = trimmed.slice(0, - suffix.length);
     const plus = local.indexOf("+");
     if (plus >= 0) {
         const idPart = local.slice(0, plus);
@@ -53,14 +53,14 @@ function parseNoreplyEmail(email: string): GithubAuthor | undefined {
     return { login: local };
 }
 
-function loadAuthorMap(json: string): Map<string, GithubAuthor> {
-    const map = new Map<string, GithubAuthor>();
+function loadAuthorMap(json: string): Map < string, GithubAuthor > {
+    const map = new Map < string, GithubAuthor > ();
     if (!json.trim()) {
         return map;
     }
-    const parsed = JSON.parse(json) as Record<string, { id?: number; login?: string }>;
-    for (const [email, entry] of Object.entries(parsed)) {
-        const author: GithubAuthor = {};
+    const parsed = JSON.parse(json)as Record < string, { id?: number; login?: string }>;
+    for (const[email, entry]of Object.entries(parsed)) {
+        const author: GithubAuthor = { };
         if (typeof entry.id === "number") {
             author.id = BigInt(entry.id);
         }
@@ -81,7 +81,7 @@ function mergeAuthors(existing: GithubAuthor, incoming: GithubAuthor): GithubAut
     };
 }
 
-async function enrichAuthor(author: GithubAuthor, token?: string, fetch = false): Promise<GithubAuthor> {
+async function enrichAuthor(author: GithubAuthor, token?: string, fetch = false) : Promise < GithubAuthor> {
     if (!fetch && author.id !== undefined && author.login !== undefined) {
         return author;
     }
@@ -95,7 +95,7 @@ async function enrichAuthor(author: GithubAuthor, token?: string, fetch = false)
     return author;
 }
 
-async function userByLoginFetch(login: string, token?: string): Promise<GithubAuthor> {
+async function userByLoginFetch(login: string, token?: string) : Promise < GithubAuthor> {
     const trimmed = login.trim();
     if (!trimmed) {
         throw new Error("login must not be empty");
@@ -104,7 +104,7 @@ async function userByLoginFetch(login: string, token?: string): Promise<GithubAu
     return parseUserJson(body, trimmed);
 }
 
-async function searchUserByEmailFetch(email: string, token: string): Promise<GithubAuthor | undefined> {
+async function searchUserByEmailFetch(email: string, token: string): Promise < GithubAuthor | undefined > {
     const trimmed = email.trim();
     const auth = token.trim();
     if (!trimmed) {
@@ -119,7 +119,7 @@ async function searchUserByEmailFetch(email: string, token: string): Promise<Git
     if (!Array.isArray(items) || items.length === 0) {
         return undefined;
     }
-    const first = items[0] as Record<string, unknown>;
+    const first = items[0]as Record < string, unknown > ;
     return parseUserJson(first);
 }
 
@@ -134,17 +134,17 @@ export type LookupUserOptions = {
  * Rust equivalent: `nifty-github` crate.
  */
 export class Github {
-    constructor(private readonly token?: string) {}
+    constructor(private readonly token?: string) { }
 
-    static open(token?: string): Github {
+    static open(token?: string) : Github {
         return new Github(token);
     }
 
-    async userByLogin(login: string, token?: string): Promise<GithubAuthor> {
+    async userByLogin(login: string, token?: string) : Promise < GithubAuthor> {
         return userByLoginFetch(login, token ?? this.token);
     }
 
-    async searchUserByEmail(email: string, token?: string): Promise<GithubAuthor | undefined> {
+    async searchUserByEmail(email: string, token?: string) : Promise < GithubAuthor | undefined > {
         const auth = token ?? this.token;
         if (!auth) {
             throw new Error("GitHub token is required for email search");
@@ -152,7 +152,7 @@ export class Github {
         return searchUserByEmailFetch(email, auth);
     }
 
-    async lookupUserByEmail(email: string, options: LookupUserOptions = {}): Promise<GithubAuthor | undefined> {
+    async lookupUserByEmail(email: string, options: LookupUserOptions = { }): Promise < GithubAuthor | undefined > {
         const token = options.token ?? this.token;
         const fetch = options.fetch ?? false;
         const mapJson = options.authorMapJson ?? "{}";
@@ -179,6 +179,6 @@ export class Github {
     }
 }
 
-export function createGithub(token?: string): Github {
+export function createGithub(token?: string) : Github {
     return Github.open(token);
 }

package/src/gitmoji.ts

@@ -8,7 +8,7 @@ export class Gitmoji {
     constructor(
         private readonly wasm: GitmojiExports,
         private readonly defaultAuthorMapJson = "{}",
-    ) {}
+    ) { }
 
     static open(authorMapJson = "{}"): Gitmoji {
         const native = loadNiftyNative();
@@ -39,7 +39,7 @@ export class Gitmoji {
         return this.wasm["leading-gitmoji"](subject);
     }
 
-    sectionForGitmoji(gitmoji?: string): ReleaseSection {
+    sectionForGitmoji(gitmoji?: string) : ReleaseSection {
         return this.wasm["section-for-gitmoji"](gitmoji);
     }