@doki-land/nifty 0.1.1 → 0.1.3

package/src/git.ts

@@ -2,60 +2,60 @@ import type { CommitRecord, RangeInfo, TagInfo } from "./types.js";
 import { loadNiftyNative, mapCommitRecord, mapRangeInfo, mapTagInfo, type GitExports } from "./native.js";
 
 export type ResolveRangeOptions = {
-    version ? : string;
-    fromRef ? : string;
-    toRef ? : string;
+    version?: string;
+    fromRef?: string;
+    toRef?: string;
 };
 
 /**
  * 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 {
+    static open(): Git {
         const native = loadNiftyNative();
         return new Git(native.git);
     }
 
     /** Walk upward from `startPath` to find the working tree root containing `.git`. */
-    discoverRoot(startPath : string) : string {
+    discoverRoot(startPath: string): string {
         return this.wasm["discover-root"](startPath);
     }
 
     /** List `v*` tags sorted by semver. */
-    listVersionTags(repoRoot : string) : string[]{
+    listVersionTags(repoRoot: string): string[] {
         return this.wasm["list-version-tags"](repoRoot);
     }
 
-    listTagInfos(repoRoot : string) : TagInfo[]{
+    listTagInfos(repoRoot: string): TagInfo[] {
         return this.wasm["list-tag-infos"](repoRoot).map(mapTagInfo);
     }
 
-    formatTagList(repoRoot : string) : string {
+    formatTagList(repoRoot: string): string {
         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),
         );
     }
 
     /** Collect non-merge commits in `fromRef..toRef` (exclusive..inclusive). */
-    collectCommits(repoRoot : string, fromRef : string | undefined, toRef : string) : CommitRecord[]{
+    collectCommits(repoRoot: string, fromRef: string | undefined, toRef: string): CommitRecord[] {
         return this.wasm["collect-commits"](repoRoot, fromRef, toRef).map(mapCommitRecord);
     }
 
-    detectGithubRepo(repoRoot : string) : string | undefined {
+    detectGithubRepo(repoRoot: string): string | undefined {
         return this.wasm["detect-github-repo"](repoRoot);
     }
 
-    parseGithubRemote(url : string) : string | undefined {
+    parseGithubRemote(url: string): string | undefined {
         return this.wasm["parse-github-remote"](url);
     }
 }
 
-export function createGit() : Git {
+export function createGit(): Git {
     return Git.open();
 }

package/src/github.ts

@@ -3,130 +3,130 @@ 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){
+    if (id === undefined && login === undefined) {
         throw new Error("GitHub user response missing id and login");
     }
     return { id, login };
 }
 
-async function getJson(url : string, token ? : string) : Promise<Record<string, unknown>>{
-    const headers : Record<string, string> = {
-        Accept : ACCEPT,
-        "User-Agent" : USER_AGENT,
+async function getJson(url: string, token?: string): Promise<Record<string, unknown>> {
+    const headers: Record<string, string> = {
+        Accept: ACCEPT,
+        "User-Agent": USER_AGENT,
     };
-    if(token ?.trim()){
+    if (token?.trim()) {
         headers.Authorization = `Bearer ${token.trim()}`;
     }
     const response = await fetch(url, { headers });
-    if(response.status === 404){
+    if (response.status === 404) {
         throw new Error("GitHub resource not found");
     }
-    if(!response.ok){
+    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 {
+function parseNoreplyEmail(email: string): GithubAuthor | undefined {
     const trimmed = email.trim();
     const suffix = "@users.noreply.github.com";
     const lower = trimmed.toLowerCase();
-    if(!lower.endsWith(suffix)){
+    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){
+    if (plus >= 0) {
         const idPart = local.slice(0, plus);
         const login = local.slice(plus + 1);
-        if(!login){
+        if (!login) {
             return undefined;
         }
-        return { id : BigInt(idPart), login };
+        return { id: BigInt(idPart), login };
     }
-    if(!local){
+    if (!local) {
         return undefined;
     }
-    return { login : local };
+    return { login: local };
 }
 
-function loadAuthorMap(json : string) : Map<string, GithubAuthor>{
+function loadAuthorMap(json: string): Map<string, GithubAuthor> {
     const map = new Map<string, GithubAuthor>();
-    if(!json.trim()){
+    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 = { };
-        if(typeof entry.id === "number"){
+    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);
         }
-        if(typeof entry.login === "string" && entry.login.trim()){
+        if (typeof entry.login === "string" && entry.login.trim()) {
             author.login = entry.login.trim();
         }
-        if(author.id!== undefined || author.login!== undefined){
+        if (author.id !== undefined || author.login !== undefined) {
             map.set(email.trim().toLowerCase(), author);
         }
     }
     return map;
 }
 
-function mergeAuthors(existing : GithubAuthor, incoming : GithubAuthor) : GithubAuthor {
+function mergeAuthors(existing: GithubAuthor, incoming: GithubAuthor): GithubAuthor {
     return {
-        id : existing.id ?? incoming.id,
-        login : existing.login ?? incoming.login,
+        id: existing.id ?? incoming.id,
+        login: existing.login ?? incoming.login,
     };
 }
 
-async function enrichAuthor(author : GithubAuthor, token ? : string, fetch = false) : Promise<GithubAuthor>{
-    if(!fetch && author.id!== undefined && author.login!== undefined){
+async function enrichAuthor(author: GithubAuthor, token?: string, fetch = false): Promise<GithubAuthor> {
+    if (!fetch && author.id !== undefined && author.login !== undefined) {
         return author;
     }
-    if(!fetch && author.id!== undefined){
+    if (!fetch && author.id !== undefined) {
         return author;
     }
-    if(author.login && (author.id === undefined || fetch)){
+    if (author.login && (author.id === undefined || fetch)) {
         const fetched = await userByLoginFetch(author.login, token);
         return mergeAuthors(author, fetched);
     }
     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){
+    if (!trimmed) {
         throw new Error("login must not be empty");
     }
     const body = await getJson(`https://api.github.com/users/${trimmed}`, token);
     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){
+    if (!trimmed) {
         throw new Error("email must not be empty");
     }
-    if(!auth){
+    if (!auth) {
         throw new Error("GitHub token is required for email search");
     }
     const query = encodeURIComponent(`${trimmed} in:email`);
     const body = await getJson(`https://api.github.com/search/users?q=${query}`, auth);
     const items = body.items;
-    if(!Array.isArray(items) || items.length === 0){
+    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);
 }
 
 export type LookupUserOptions = {
-    authorMapJson ? : string;
-    token ? : string;
-    fetch ? : boolean;
+    authorMapJson?: string;
+    token?: string;
+    fetch?: boolean;
 };
 
 /**
@@ -134,43 +134,43 @@ 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){
+        if (!auth) {
             throw new Error("GitHub token is required for email search");
         }
         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 ?? "{}";
 
         const fromNoreply = parseNoreplyEmail(email);
-        if(fromNoreply){
+        if (fromNoreply) {
             return enrichAuthor(fromNoreply, token, fetch);
         }
 
         const map = loadAuthorMap(mapJson);
         const mapped = map.get(email.trim().toLowerCase());
-        if(mapped){
+        if (mapped) {
             return enrichAuthor(mapped, token, fetch);
         }
 
-        if(token){
+        if (token) {
             const found = await searchUserByEmailFetch(email, token);
-            if(found){
+            if (found) {
                 return enrichAuthor(found, token, fetch);
             }
         }
@@ -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

@@ -6,72 +6,72 @@ import { loadNiftyNative, type GitmojiExports } from "./native.js";
  */
 export class Gitmoji {
     constructor(
-        private readonly wasm : GitmojiExports,
+        private readonly wasm: GitmojiExports,
         private readonly defaultAuthorMapJson = "{}",
-    ){ }
+    ) {}
 
-    static open(authorMapJson = "{}") : Gitmoji {
+    static open(authorMapJson = "{}"): Gitmoji {
         const native = loadNiftyNative();
         return new Gitmoji(native.gitmoji, authorMapJson);
     }
 
-    knownGitmojis() : string[]{
+    knownGitmojis(): string[] {
         return this.wasm["known-gitmojis"]();
     }
 
-    validateSubject(subject : string) : boolean {
+    validateSubject(subject: string): boolean {
         return this.wasm["validate-subject"](subject);
     }
 
-    parseSubject(subject : string) : ParsedSubject {
+    parseSubject(subject: string): ParsedSubject {
         return this.wasm["parse-subject"](subject);
     }
 
-    formatSubject(gitmoji : string, body : string) : string {
+    formatSubject(gitmoji: string, body: string): string {
         return this.wasm["format-subject"](gitmoji, body);
     }
 
-    stripGitmoji(subject : string) : string {
+    stripGitmoji(subject: string): string {
         return this.wasm["strip-gitmoji"](subject);
     }
 
-    leadingGitmoji(subject : string) : string | undefined {
+    leadingGitmoji(subject: string): string | undefined {
         return this.wasm["leading-gitmoji"](subject);
     }
 
-    sectionForGitmoji(gitmoji ? : string) : ReleaseSection {
+    sectionForGitmoji(gitmoji?: string): ReleaseSection {
         return this.wasm["section-for-gitmoji"](gitmoji);
     }
 
-    parseNoreplyEmail(email : string) : GithubAuthor | undefined {
+    parseNoreplyEmail(email: string): GithubAuthor | undefined {
         return this.wasm["parse-noreply-email"](email);
     }
 
-    resolveGithubAuthor(email : string, authorMapJson = this.defaultAuthorMapJson) : GithubAuthor | undefined {
+    resolveGithubAuthor(email: string, authorMapJson = this.defaultAuthorMapJson): GithubAuthor | undefined {
         return this.wasm["resolve-github-author"](email, authorMapJson);
     }
 
-    displayLogin(author : GithubAuthor) : string {
+    displayLogin(author: GithubAuthor): string {
         return this.wasm["display-login"](author);
     }
 
-    profileUrl(author : GithubAuthor) : string {
+    profileUrl(author: GithubAuthor): string {
         return this.wasm["profile-url"](author);
     }
 
-    avatarUrl(author : GithubAuthor) : string {
+    avatarUrl(author: GithubAuthor): string {
         return this.wasm["avatar-url"](author);
     }
 
-    authorMention(email : string, authorName : string, authorMapJson = this.defaultAuthorMapJson) : string {
+    authorMention(email: string, authorName: string, authorMapJson = this.defaultAuthorMapJson): string {
         return this.wasm["author-mention"](email, authorName, authorMapJson);
     }
 
-    commitBullet(body : string, email : string, authorName : string, authorMapJson = this.defaultAuthorMapJson) : string {
+    commitBullet(body: string, email: string, authorName: string, authorMapJson = this.defaultAuthorMapJson): string {
         return this.wasm["commit-bullet"](body, email, authorName, authorMapJson);
     }
 }
 
-export function createGitmoji() : Gitmoji {
+export function createGitmoji(): Gitmoji {
     return Gitmoji.open();
 }