@doki-land/nifty 0.1.1 → 0.1.3

package/src/cli/retime-cmd.ts

@@ -4,7 +4,7 @@ import { loadNiftyNative } from "../native.js";
 import { bootstrapFromOptions } from "./context.js";
 import { cwdFrom, str } from "./options.js";
 
-export function registerRetimeCommand(cli : Cli) : void {
+export function registerRetimeCommand(cli: Cli): void {
     const retime = cli.command("retime", "cli.cmd.retime")
         .option("-s, --start-date <start>", "cli.opt.start-date")
         .option("--end-date <end>", "cli.opt.end-date")
@@ -18,45 +18,45 @@ export function registerRetimeCommand(cli : Cli) : void {
         .option("-b, --branch <branch>", "cli.opt.branch")
         .option("--tip <ref>", "cli.opt.tip")
         .option("-m, --message <text>", "cli.opt.message")
-        .action(async(options) =>cmdRetimeRoot(options));
+        .action(async (options) => cmdRetimeRoot(options));
 
-    retime.action(async(options) =>cmdRetimeRange(options));
+    retime.action(async (options) => cmdRetimeRange(options));
 }
 
-export async function cmdRetimeRange(options : ParsedOptions) : Promise<number>{
+export async function cmdRetimeRange(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const commit = options._[0];
-    if(!commit){
+    if (!commit) {
         throw new Error("missing commit hash for range retime");
     }
     const native = loadNiftyNative();
     const report = native.history["retime-range"]({
-        cwd : cwdFrom(options),
+        cwd: cwdFrom(options),
         commit,
-        startDate : str(options, "start-date"),
-        endDate : str(options, "end-date"),
-        branch : str(options, "branch"),
-        tip : str(options, "tip"),
+        startDate: str(options, "start-date"),
+        endDate: str(options, "end-date"),
+        branch: str(options, "branch"),
+        tip: str(options, "tip"),
     });
     printRetimeSummary(report);
     return 0;
 }
 
-export async function cmdRetimeRoot(options : ParsedOptions) : Promise<number>{
+export async function cmdRetimeRoot(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const native = loadNiftyNative();
     const report = native.history["retime-root"]({
-        cwd : cwdFrom(options),
-        startDate : str(options, "start-date"),
-        endDate : str(options, "end-date"),
-        branch : str(options, "branch"),
-        tip : str(options, "tip"),
-        message : str(options, "message"),
+        cwd: cwdFrom(options),
+        startDate: str(options, "start-date"),
+        endDate: str(options, "end-date"),
+        branch: str(options, "branch"),
+        tip: str(options, "tip"),
+        message: str(options, "message"),
     });
     printRetimeSummary(report);
     return 0;
 }
 
-function printRetimeSummary(report : { rewritten : number; branch : string; newTip : string }) : void {
+function printRetimeSummary(report: { rewritten: number; branch: string; newTip: string }): void {
     console.log(`retimed ${report.rewritten} commit(s) on branch ${report.branch}; tip ${report.newTip}`);
 }

package/src/cli/trust-cmd.ts

@@ -8,7 +8,7 @@ import { bootstrapFromOptions } from "./context.js";
 import { printTrustReport } from "./trust.js";
 import { authFromOptions, cwdFrom, flag, str } from "./options.js";
 
-export function registerTrustCommand(cli : Cli) : void {
+export function registerTrustCommand(cli: Cli): void {
     cli.command("trust", "cli.cmd.trust")
         .option("--dry-run", "cli.opt.dry-run")
         .option("--refresh", "cli.opt.refresh")
@@ -16,25 +16,25 @@ export function registerTrustCommand(cli : Cli) : void {
         .option("--otp <code>", "cli.opt.otp")
         .option("--totp-secret <secret>", "cli.opt.totp-secret")
         .option("--npm-token <token>", "cli.opt.npm-token")
-        .action(async(options) =>cmdTrust(options));
+        .action(async (options) => cmdTrust(options));
 }
 
-export async function cmdTrust(options : ParsedOptions) : Promise<number>{
+export async function cmdTrust(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
-    const { config } = await loadConfig({ cwd : cwdFrom(options), createIfMissing : false });
+    const { config } = await loadConfig({ cwd: cwdFrom(options), createIfMissing: false });
     const native = loadNiftyNative();
-    const fromConfig = config.publish ?.packages ?? [];
+    const fromConfig = config.publish?.packages ?? [];
     const report = native.publisher["trust-workspace"]({
-        cwd : cwdFrom(options),
-        dryRun : flag(options, "dry-run"),
-        refresh : flag(options, "refresh"),
-        only : str(options, "only"),
-        ...(fromConfig.length>0 ? { packages : fromConfig } : { }),
+        cwd: cwdFrom(options),
+        dryRun: flag(options, "dry-run"),
+        refresh: flag(options, "refresh"),
+        only: str(options, "only"),
+        ...(fromConfig.length > 0 ? { packages: fromConfig } : {}),
         ...trustPayloadFromConfig(config),
         ...authPayload(authFromOptions(options)),
     });
     printTrustReport(report);
-    if(report.failed.length>0){
+    if (report.failed.length > 0) {
         throw new Error(`trust failed for ${report.failed.length} package(s)`);
     }
     return 0;

package/src/cli/trust.ts

@@ -2,43 +2,43 @@ import { loadNiftyNative } from "../native.js";
 import { authPayload, parseAuthArgs } from "./authArgs.js";
 
 export type TrustReport = {
-    root : string;
-    configured : string[];
-    skipped : string[];
-    failed : string[];
+    root: string;
+    configured: string[];
+    skipped: string[];
+    failed: string[];
 };
 
-export async function runTrust(argv : string[]) : Promise<void>{
+export async function runTrust(argv: string[]): Promise<void> {
     const options = parseTrustArgs(argv);
     const native = loadNiftyNative();
     const report = native.publisher["trust-workspace"]({
-        cwd : options.cwd,
-        dryRun : options.dryRun,
-        refresh : options.refresh,
-        only : options.only,
+        cwd: options.cwd,
+        dryRun: options.dryRun,
+        refresh: options.refresh,
+        only: options.only,
         ...authPayload(options.auth),
     });
     printTrustReport(report);
 }
 
-function parseTrustArgs(argv : string[]){
-    let cwd : string | undefined;
+function parseTrustArgs(argv: string[]) {
+    let cwd: string | undefined;
     let dryRun = false;
     let refresh = false;
-    let only : string | undefined;
+    let only: string | undefined;
     const auth = parseAuthArgs(argv);
 
-    for(let i = 0; i<argv.length; i += 1){
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "--dry-run"){
+        if (arg === "--dry-run") {
             dryRun = true;
-        } else if(arg === "--refresh"){
+        } else if (arg === "--refresh") {
             refresh = true;
-        } else if(arg === "-C" || arg === "--cwd"){
-            cwd = argv[ ++ i];
-        } else if(arg === "--only"){
-            only = argv[ ++ i];
-        } else if(arg === "-h" || arg === "--help"){
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
+        } else if (arg === "--only") {
+            only = argv[++i];
+        } else if (arg === "-h" || arg === "--help") {
             printTrustHelp();
             process.exit(0);
         }
@@ -47,25 +47,25 @@ function parseTrustArgs(argv : string[]){
     return { cwd, dryRun, refresh, only, auth };
 }
 
-export function printTrustReport(report : TrustReport) : void {
+export function printTrustReport(report: TrustReport): void {
     console.log(`trust workspace ${report.root}`);
     console.log(`  configured: ${report.configured.length}`);
-    for(const name of report.configured){
+    for (const name of report.configured) {
         console.log(`    + ${name}`);
     }
     console.log(`  skipped: ${report.skipped.length}`);
-    for(const name of report.skipped){
+    for (const name of report.skipped) {
         console.log(`    = ${name}`);
     }
-    if(report.failed.length>0){
+    if (report.failed.length > 0) {
         console.log(`  failed: ${report.failed.length}`);
-        for(const name of report.failed){
+        for (const name of report.failed) {
             console.log(`    ! ${name}`);
         }
     }
 }
 
-function printTrustHelp() : void {
+function printTrustHelp(): void {
     console.log(`nifty trust — configure npm Trusted Publisher for workspace packages
 
 Reads trust.npm from nifty.config.ts (repo / file / environment).

package/src/cli/update-cmd.ts

@@ -4,17 +4,17 @@ import { bootstrapFromOptions } from "./context.js";
 import { updateWorkspace } from "./update.js";
 import { cwdFrom, flag } from "./options.js";
 
-export function registerUpdateCommand(cli : Cli) : void {
+export function registerUpdateCommand(cli: Cli): void {
     cli.command("update", "cli.cmd.update")
         .option("-i, --interactive", "cli.opt.interactive")
-        .action(async(options) =>cmdUpdate(options));
+        .action(async (options) => cmdUpdate(options));
 }
 
-export async function cmdUpdate(options : ParsedOptions) : Promise<number>{
+export async function cmdUpdate(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     await updateWorkspace({
-        interactive : flag(options, "interactive"),
-        cwd : cwdFrom(options),
+        interactive: flag(options, "interactive"),
+        cwd: cwdFrom(options),
     });
     return 0;
 }

package/src/cli/update.ts

@@ -1,31 +1,31 @@
 import { loadNiftyNative } from "../native.js";
 
 export type UpdateOptions = {
-    interactive : boolean;
-    cwd ? : string;
+    interactive: boolean;
+    cwd?: string;
 };
 
-export async function runUpdate(argv : string[]) : Promise<void>{
+export async function runUpdate(argv: string[]): Promise<void> {
     await updateWorkspace(parseUpdateArgs(argv));
 }
 
-export async function updateWorkspace(options : UpdateOptions) : Promise<void>{
+export async function updateWorkspace(options: UpdateOptions): Promise<void> {
     const native = loadNiftyNative();
     native.updater.run({
-        cwd : options.cwd,
-        interactive : options.interactive,
+        cwd: options.cwd,
+        interactive: options.interactive,
     });
 }
 
-function parseUpdateArgs(argv : string[]) : UpdateOptions {
+function parseUpdateArgs(argv: string[]): UpdateOptions {
     let interactive = false;
-    let cwd : string | undefined;
-    for(let i = 0; i<argv.length; i += 1){
+    let cwd: string | undefined;
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "-i" || arg === "--interactive"){
+        if (arg === "-i" || arg === "--interactive") {
             interactive = true;
-        } else if(arg === "-C" || arg === "--cwd"){
-            cwd = argv[ ++ i];
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
         }
     }
     return { interactive, cwd };

package/src/cli/upload-cmd.ts

@@ -4,7 +4,7 @@ import { bootstrapFromOptions } from "./context.js";
 import { uploadFromOptions } from "./upload.js";
 import { cwdFrom, flag, str } from "./options.js";
 
-export function registerUploadCommand(cli : Cli) : void {
+export function registerUploadCommand(cli: Cli): void {
     cli.command("upload", "cli.cmd.upload")
         .option("--release", "cli.opt.release")
         .option("--pages", "cli.opt.pages")
@@ -19,26 +19,26 @@ export function registerUploadCommand(cli : Cli) : void {
         .option("--draft", "cli.opt.draft")
         .option("--no-generate-notes", "cli.opt.no-generate-notes")
         .option("--github-action", "cli.opt.github-action")
-        .action(async(options) =>cmdUpload(options));
+        .action(async (options) => cmdUpload(options));
 }
 
-export async function cmdUpload(options : ParsedOptions) : Promise<number>{
+export async function cmdUpload(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     await uploadFromOptions({
-        release : flag(options, "release"),
-        pages : flag(options, "pages"),
-        both : flag(options, "both"),
-        dir : str(options, "dir") ?? "dist",
-        tag : str(options, "tag"),
-        repo : str(options, "repo"),
-        token : str(options, "token"),
-        name : str(options, "name"),
-        notes : str(options, "notes"),
-        notesFile : str(options, "notes-file"),
-        draft : flag(options, "draft"),
-        generateNotes : !flag(options, "no-generate-notes"),
-        githubAction : flag(options, "github-action"),
-        cwd : cwdFrom(options),
+        release: flag(options, "release"),
+        pages: flag(options, "pages"),
+        both: flag(options, "both"),
+        dir: str(options, "dir") ?? "dist",
+        tag: str(options, "tag"),
+        repo: str(options, "repo"),
+        token: str(options, "token"),
+        name: str(options, "name"),
+        notes: str(options, "notes"),
+        notesFile: str(options, "notes-file"),
+        draft: flag(options, "draft"),
+        generateNotes: !flag(options, "no-generate-notes"),
+        githubAction: flag(options, "github-action"),
+        cwd: cwdFrom(options),
     });
     return 0;
 }