@monorepolint/utils 0.6.0-alpha.1 → 0.6.0-alpha.3

package/src/CachingHost.ts

@@ -6,10 +6,12 @@
  */
 
 import * as realFs from "node:fs";
-import { Host } from "./Host.js";
 import * as path from "node:path";
+import { Host } from "./Host.js";
 
-function assertNoTombstone(node: Node): asserts node is Node & { tombstone?: false } {
+function assertNoTombstone(
+  node: Node,
+): asserts node is Node & { tombstone?: false } {
   if (node.tombstone) {
     throw new Error(`Unexpected tombstone ${JSON.stringify(node)}`);
   }
@@ -17,14 +19,17 @@ function assertNoTombstone(node: Node): asserts node is Node & { tombstone?: fal
 
 function assertNotType<N extends Node, T extends Node["type"]>(
   node: N,
-  type: T
+  type: T,
 ): asserts node is N & { type: Exclude<N["type"], T> } {
   if (node.type === type) {
     throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
   }
 }
 
-function assertType<N extends Node, T extends Node["type"]>(node: N, type: T): asserts node is N & { type: T } {
+function assertType<N extends Node, T extends Node["type"]>(
+  node: N,
+  type: T,
+): asserts node is N & { type: T } {
   if (node.type !== type) {
     throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
   }
@@ -90,7 +95,14 @@ interface SymlinkNode extends BaseNode<"symlink"> {
   symlink: string;
 }
 
-type Node = DirNode | FileNode | SymlinkNode | DirTombstoneNode | FileTombstoneNode | DirStubNode | FileStubNode;
+type Node =
+  | DirNode
+  | FileNode
+  | SymlinkNode
+  | DirTombstoneNode
+  | FileTombstoneNode
+  | DirStubNode
+  | FileStubNode;
 
 export class CachingHost implements Host {
   // We need many trees because of windows, key is the `root`
@@ -111,23 +123,29 @@ export class CachingHost implements Host {
       | "statSync"
       | "unlinkSync"
       | "writeFileSync"
-    > = realFs
+    > = realFs,
   ) {}
 
   #replaceNode(
     node: FileNode | FileStubNode | SymlinkNode,
-    newNode: Omit<FileTombstoneNode, "fullPath" | "parent">
+    newNode: Omit<FileTombstoneNode, "fullPath" | "parent">,
   ): FileTombstoneNode;
   #replaceNode(
     node: FileNode | FileStubNode | FileTombstoneNode,
-    newNode: Omit<FileNode, "fullPath" | "parent">
+    newNode: Omit<FileNode, "fullPath" | "parent">,
   ): FileNode;
   #replaceNode(
     node: DirTombstoneNode | DirStubNode,
-    newNode: Omit<DirNode, "fullPath" | "parent" | "dir">
+    newNode: Omit<DirNode, "fullPath" | "parent" | "dir">,
   ): DirStubNode;
-  #replaceNode(node: DirNode, newNode: Omit<DirTombstoneNode, "fullPath" | "parent" | "dir">): DirTombstoneNode;
-  #replaceNode(node: Node, partialNewNode: Omit<Node, "fullPath" | "parent">): Node {
+  #replaceNode(
+    node: DirNode,
+    newNode: Omit<DirTombstoneNode, "fullPath" | "parent" | "dir">,
+  ): DirTombstoneNode;
+  #replaceNode(
+    node: Node,
+    partialNewNode: Omit<Node, "fullPath" | "parent">,
+  ): Node {
     if (!node.parent) throw new Error("Cannot replace root node");
     const newNode: Node = {
       ...partialNewNode,
@@ -156,15 +174,22 @@ export class CachingHost implements Host {
    * Throws if the path doesnt exist!
    */
   #stubify(filePath: string, parent: undefined): DirStubNode;
-  #stubify(filePath: string, parent: DirNode | DirStubNode | undefined): DirStubNode | SymlinkNode | FileStubNode;
   #stubify(
     filePath: string,
-    parent: DirNode | DirStubNode | undefined
-  ): typeof parent extends undefined ? DirNode | DirStubNode : DirNode | DirStubNode | SymlinkNode | FileStubNode {
+    parent: DirNode | DirStubNode | undefined,
+  ): DirStubNode | SymlinkNode | FileStubNode;
+  #stubify(
+    filePath: string,
+    parent: DirNode | DirStubNode | undefined,
+  ): typeof parent extends undefined ? DirNode | DirStubNode
+    : DirNode | DirStubNode | SymlinkNode | FileStubNode
+  {
     const canonicalPath = path.resolve(filePath);
 
     if (!parent && canonicalPath !== path.parse(canonicalPath).root) {
-      throw new Error(`parent can only be null if path is root. Instead got: ${canonicalPath}`);
+      throw new Error(
+        `parent can only be null if path is root. Instead got: ${canonicalPath}`,
+      );
     }
     const stat = this.fs.lstatSync(canonicalPath); // may throw
 
@@ -196,7 +221,9 @@ export class CachingHost implements Host {
         needsFlush: false,
       };
     } else {
-      throw new Error(`what is not a file nor symlink nor directory? nothing we care about: ${canonicalPath}`);
+      throw new Error(
+        `what is not a file nor symlink nor directory? nothing we care about: ${canonicalPath}`,
+      );
     }
 
     if (!parent && node.type === "dir") {
@@ -205,7 +232,11 @@ export class CachingHost implements Host {
     } else if (parent) {
       parent.dir.set(path.basename(canonicalPath), node);
     } else {
-      throw new Error(`root can only be a dir, got ${JSON.stringify(node)} for path: ${canonicalPath}`);
+      throw new Error(
+        `root can only be a dir, got ${
+          JSON.stringify(node)
+        } for path: ${canonicalPath}`,
+      );
     }
     return node;
   }
@@ -226,13 +257,16 @@ export class CachingHost implements Host {
     }
 
     let curPath = root;
-    let curNode: Node = this.#trees.get(root) ?? this.#stubify(curPath, undefined); // its okay to throw if there is no root
+    let curNode: Node = this.#trees.get(root)
+      ?? this.#stubify(curPath, undefined); // its okay to throw if there is no root
     try {
       for (const part of parts) {
         assertNoTombstone(curNode);
         assertNotType(curNode, "file");
         if (curNode.type === "symlink") {
-          const linkedNode = this.#getNodeResolvingSymlinks(path.resolve(path.dirname(curPath), curNode.symlink));
+          const linkedNode = this.#getNodeResolvingSymlinks(
+            path.resolve(path.dirname(curPath), curNode.symlink),
+          );
           assertExists(linkedNode);
           assertNoTombstone(linkedNode);
           assertType(linkedNode, "dir");
@@ -240,9 +274,11 @@ export class CachingHost implements Host {
         }
         assertType(curNode, "dir");
         assertNoTombstone(curNode);
-        curNode = curNode.dir.get(part) ?? this.#stubify(path.join(curNode.fullPath, part), curNode);
+        curNode = curNode.dir.get(part)
+          ?? this.#stubify(path.join(curNode.fullPath, part), curNode);
         curPath = path.join(curPath, part);
       }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
     } catch (e) {
       // This error is expected when things done exist.
       // console.log(`Got EXPECTED error when trying to getNearestAncestorNode(${canonicalPath}): `, (e as any).message);
@@ -252,14 +288,19 @@ export class CachingHost implements Host {
 
   #getNode(filePath: string) {
     const canonicalPath = path.resolve(filePath);
-    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(canonicalPath);
+    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(
+      canonicalPath,
+    );
     if (pathWithSymlinks === canonicalPath) {
       return node;
     }
     return undefined;
   }
 
-  #getNodeResolvingSymlinks(filePath: string, follows: number = 100): Exclude<Node, SymlinkNode> | undefined {
+  #getNodeResolvingSymlinks(
+    filePath: string,
+    follows: number = 100,
+  ): Exclude<Node, SymlinkNode> | undefined {
     const node = this.#getNode(filePath); // canonicalizes for us
     if (!node || node.type !== "symlink") return node;
     // this is a really poor mans way of doing this. but who has 100's of symlinks hanging around?
@@ -268,9 +309,14 @@ export class CachingHost implements Host {
     return this.#getNodeResolvingSymlinks(node.symlink, follows--);
   }
 
-  mkdir(filePath: string, opts: { recursive: boolean } = { recursive: false }): void {
+  mkdir(
+    filePath: string,
+    opts: { recursive: boolean } = { recursive: false },
+  ): void {
     const canonicalPath = path.resolve(filePath);
-    const { node, pathWithSymlinks } = this.#getNearestAncestorNode(canonicalPath);
+    const { node, pathWithSymlinks } = this.#getNearestAncestorNode(
+      canonicalPath,
+    );
     if (filePath === pathWithSymlinks) {
       assertType(node, "dir");
       assertHasParent(node);
@@ -296,7 +342,9 @@ export class CachingHost implements Host {
     let maybePath = canonicalPath;
     const toMake: string[] = [];
     while (maybePath !== rootPath) {
-      toMake.unshift(path.resolve(node.fullPath, path.relative(rootPath, maybePath)));
+      toMake.unshift(
+        path.resolve(node.fullPath, path.relative(rootPath, maybePath)),
+      );
       maybePath = path.dirname(maybePath);
     }
 
@@ -336,7 +384,10 @@ export class CachingHost implements Host {
   readFile(filePath: string, opts: { asJson: true }): object;
   readFile(
     filePath: string,
-    opts: undefined | { encoding: BufferEncoding; asJson?: false } | { encoding?: never; asJson: true }
+    opts: undefined | { encoding: BufferEncoding; asJson?: false } | {
+      encoding?: never;
+      asJson: true;
+    },
   ) {
     let node = this.#getNodeResolvingSymlinks(filePath); // canonicalizes for us
 
@@ -364,10 +415,24 @@ export class CachingHost implements Host {
   }
 
   writeFile(filePath: string, buffer: Buffer): void;
-  writeFile(filePath: string, body: string, opts: { encoding: BufferEncoding }): void;
-  writeFile(filePath: string, body: string, opts: { encoding: BufferEncoding }): void;
-  writeFile(filePath: string, body: string | Buffer, opts?: { encoding: BufferEncoding }) {
-    const fileContentsAsBuffer = typeof body === "string" ? Buffer.from(body, opts?.encoding) : Buffer.from(body);
+  writeFile(
+    filePath: string,
+    body: string,
+    opts: { encoding: BufferEncoding },
+  ): void;
+  writeFile(
+    filePath: string,
+    body: string,
+    opts: { encoding: BufferEncoding },
+  ): void;
+  writeFile(
+    filePath: string,
+    body: string | Buffer,
+    opts?: { encoding: BufferEncoding },
+  ) {
+    const fileContentsAsBuffer = typeof body === "string"
+      ? Buffer.from(body, opts?.encoding)
+      : Buffer.from(body);
 
     const canonicalPath = path.resolve(filePath);
     const existingNode = this.#getNodeResolvingSymlinks(canonicalPath);
@@ -383,7 +448,9 @@ export class CachingHost implements Host {
       return;
     }
 
-    const maybeDirNode = this.#getNodeResolvingSymlinks(path.dirname(canonicalPath));
+    const maybeDirNode = this.#getNodeResolvingSymlinks(
+      path.dirname(canonicalPath),
+    );
     assertExists(maybeDirNode);
     assertType(maybeDirNode, "dir");
     assertNoTombstone(maybeDirNode);
@@ -419,12 +486,15 @@ export class CachingHost implements Host {
     });
   }
 
-  async #flushFileNode(node: FileNode | FileStubNode | FileTombstoneNode): Promise<unknown> {
+  async #flushFileNode(
+    node: FileNode | FileStubNode | FileTombstoneNode,
+  ): Promise<unknown> {
     // FIXME all tombstones need a flush, so we can get rid of needsFlush for them
     if (node.tombstone) {
       try {
         await this.fs.promises.access(node.fullPath);
         return this.fs.promises.unlink(node.fullPath);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
       } catch (e) {
         // should only throw if file doesnt exist which is no op
         return;
@@ -444,16 +514,20 @@ export class CachingHost implements Host {
       if (linkValue === node.symlink) {
         return;
       }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
     } catch (e) {
       // expected when the link doesnt exist
     }
     return this.fs.promises.symlink(node.symlink, node.fullPath);
   }
 
-  async #flushDirNode(node: DirNode | DirStubNode | DirTombstoneNode): Promise<unknown> {
+  async #flushDirNode(
+    node: DirNode | DirStubNode | DirTombstoneNode,
+  ): Promise<unknown> {
     if (!node.tombstone && node.needsFlush) {
       try {
         await this.fs.promises.access(node.fullPath); // throws if the file doesnt exist
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
       } catch (e) {
         await this.fs.promises.mkdir(node.fullPath); // throws if it does :(
       }
@@ -462,7 +536,9 @@ export class CachingHost implements Host {
     const promises: Promise<unknown>[] = [];
     for (const child of node.dir.values()) {
       if (node.tombstone && !child.tombstone) {
-        throw new Error("Unexpected failure during sanity check. A non-deleted child is on a deleted dir");
+        throw new Error(
+          "Unexpected failure during sanity check. A non-deleted child is on a deleted dir",
+        );
       }
       if (child.type === "dir") {
         promises.push(this.#flushDirNode(child));

package/src/Host.ts

@@ -19,7 +19,11 @@ export interface Host {
   writeJson(path: string, o: object): void;
 
   writeFile(path: string, buffer: Buffer): void;
-  writeFile(path: string, body: string, opts: { encoding: BufferEncoding }): void;
+  writeFile(
+    path: string,
+    body: string,
+    opts: { encoding: BufferEncoding },
+  ): void;
 
   readFile(path: string, opts?: undefined): Buffer;
   readFile(path: string, opts: { encoding: BufferEncoding }): string;

package/src/PackageJson.ts

@@ -14,9 +14,9 @@ export interface PackageJson {
   optionalDependencies?: Record<string, string>;
   workspaces?:
     | {
-        packages?: string[];
-        nohoist?: string[];
-      }
+      packages?: string[];
+      nohoist?: string[];
+    }
     | string[];
   [otherKey: string]: unknown;
 }

package/src/SimpleHost.ts

@@ -22,8 +22,16 @@ export class SimpleHost implements Host {
   }
 
   writeFile(path: string, buffer: Buffer): void;
-  writeFile(path: string, body: string, opts: { encoding: BufferEncoding }): void;
-  writeFile(path: string, body: string | Buffer, opts?: { encoding: BufferEncoding }): void {
+  writeFile(
+    path: string,
+    body: string,
+    opts: { encoding: BufferEncoding },
+  ): void;
+  writeFile(
+    path: string,
+    body: string | Buffer,
+    opts?: { encoding: BufferEncoding },
+  ): void {
     if (opts) {
       this.fs.writeFileSync(path, body, { encoding: opts.encoding });
     } else {
@@ -33,7 +41,10 @@ export class SimpleHost implements Host {
   readFile(path: string, opts?: undefined): Buffer;
   readFile(path: string, opts: { encoding: BufferEncoding }): string;
   readFile(path: string, opts: { asJson: true }): object;
-  readFile(path: string, opts?: { encoding?: BufferEncoding; asJson?: boolean }): string | object | Buffer {
+  readFile(
+    path: string,
+    opts?: { encoding?: BufferEncoding; asJson?: boolean },
+  ): string | object | Buffer {
     if (opts?.asJson) {
       return JSON.parse(this.fs.readFileSync(path, "utf-8"));
     }

package/src/Table.ts

@@ -6,8 +6,9 @@
  */
 // tslint:disable:no-console
 import { nanosecondsToSanity } from "./nanosecondsToSanity.js";
-type HeaderFooterHelper<HB, FB, H, F> = (HB extends true ? { header: H } : { header?: H }) &
-  (FB extends true ? { footer: F } : { footer?: F });
+type HeaderFooterHelper<HB, FB, H, F> =
+  & (HB extends true ? { header: H } : { header?: H })
+  & (FB extends true ? { footer: F } : { footer?: F });
 
 type WithAlignemnt = { alignment?: "right" | "left" };
 type BaseCellConfig = WithAlignemnt & { type: "bigint" | "string" };
@@ -19,13 +20,20 @@ type BaseBigIntCellConfig = {
 } & WithAlignemnt;
 type BaseStringCellConfig = { type: "string" } & WithAlignemnt;
 
-type BigIntColumnConfig<H, F> = WithAlignemnt &
-  BaseBigIntCellConfig &
-  HeaderFooterHelper<H, F, string, AggregateFooterConfig | StaticFooterConfig>;
-
-type StringColumnConfig<H, F> = WithAlignemnt &
-  BaseStringCellConfig &
-  HeaderFooterHelper<H, F, string, StaticFooterConfig>;
+type BigIntColumnConfig<H, F> =
+  & WithAlignemnt
+  & BaseBigIntCellConfig
+  & HeaderFooterHelper<
+    H,
+    F,
+    string,
+    AggregateFooterConfig | StaticFooterConfig
+  >;
+
+type StringColumnConfig<H, F> =
+  & WithAlignemnt
+  & BaseStringCellConfig
+  & HeaderFooterHelper<H, F, string, StaticFooterConfig>;
 
 type AggregateFooterConfig = {
   aggregate: "sum" | "average";
@@ -47,7 +55,8 @@ type TableConfig<T extends any[], H extends boolean, F extends boolean> = {
   showHeader: H;
   showFooter: F;
   columns: {
-    [K in keyof T]: T[K] extends bigint ? BigIntColumnConfig<H, F> : StringColumnConfig<H, F>;
+    [K in keyof T]: T[K] extends bigint ? BigIntColumnConfig<H, F>
+      : StringColumnConfig<H, F>;
   };
   title: string;
 };
@@ -74,7 +83,7 @@ export class Table<T extends any[]> {
       | TableConfig<T, true, true>
       | TableConfig<T, true, false>
       | TableConfig<T, false, true>
-      | TableConfig<T, false, false>
+      | TableConfig<T, false, false>,
   ) {
     this.#config = {
       padding: 2,
@@ -101,7 +110,9 @@ export class Table<T extends any[]> {
             ...columnConfig.footer,
           });
         } else if ("aggregate" in columnConfig.footer) {
-          if (columnConfig.type !== "bigint") throw new Error("expecting bigint for aggregate");
+          if (columnConfig.type !== "bigint") {
+            throw new Error("expecting bigint for aggregate");
+          }
           this.#footerRowConfig.push({
             type: columnConfig.type,
             renderAs: columnConfig.renderAs,
@@ -155,10 +166,15 @@ export class Table<T extends any[]> {
       const colConfig = this.#config.columns[c];
       this.#columnWidths[c] = Math.max(
         (this.#config.columns[c].header ?? "").length,
-        ...this.#rows.map((a) => this.#getCellValueAsString(a[c], colConfig).length),
+        ...this.#rows.map((a) =>
+          this.#getCellValueAsString(a[c], colConfig).length
+        ),
         this.#footer && this.#footerRowConfig
-          ? this.#getCellValueAsString(this.#footer?.[c] ?? "", this.#footerRowConfig[c]).length
-          : 0
+          ? this.#getCellValueAsString(
+            this.#footer?.[c] ?? "",
+            this.#footerRowConfig[c],
+          ).length
+          : 0,
       );
     }
 
@@ -208,7 +224,9 @@ export class Table<T extends any[]> {
 
       let hr = "";
       for (let c = 0; c < footerRow.length; c++) {
-        hr += this.#getCellValueAligned(footerRow[c], this.#footerRowConfig![c], c) + paddingString; // .padEnd(this.#columnWidths[c], " ") + paddingString;
+        hr +=
+          this.#getCellValueAligned(footerRow[c], this.#footerRowConfig![c], c)
+          + paddingString; // .padEnd(this.#columnWidths[c], " ") + paddingString;
       }
       hr = hr.trimRight();
       console.log(hr);
@@ -246,7 +264,10 @@ export class Table<T extends any[]> {
     console.log();
   }
 
-  #getCellValueAsString(value: bigint | string, config: BaseBigIntCellConfig | BaseStringCellConfig) {
+  #getCellValueAsString(
+    value: bigint | string,
+    config: BaseBigIntCellConfig | BaseStringCellConfig,
+  ) {
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
       return nanosecondsToSanity(value as bigint, config.precision ?? 9);
     } else {
@@ -254,7 +275,11 @@ export class Table<T extends any[]> {
     }
   }
 
-  #getCellValueAligned(value: bigint | string, config: BaseBigIntCellConfig | BaseStringCellConfig, column: number) {
+  #getCellValueAligned(
+    value: bigint | string,
+    config: BaseBigIntCellConfig | BaseStringCellConfig,
+    column: number,
+  ) {
     let result: string;
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
       result = nanosecondsToSanity(value as bigint, config.precision ?? 9);
@@ -273,7 +298,10 @@ export class Table<T extends any[]> {
     const config = this.#config.columns[colNum];
 
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      return nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
+      return nanosecondsToSanity(
+        this.#rows[rowNum][colNum],
+        config.precision ?? 9,
+      );
     } else {
       return "" + this.#rows[rowNum][colNum];
     }
@@ -284,7 +312,10 @@ export class Table<T extends any[]> {
 
     let result: string;
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      result = nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
+      result = nanosecondsToSanity(
+        this.#rows[rowNum][colNum],
+        config.precision ?? 9,
+      );
     } else {
       result = "" + this.#rows[rowNum][colNum];
     }
@@ -296,12 +327,20 @@ export class Table<T extends any[]> {
     }
   }
 
-  getColumnWidth(colNum: number, config: BigIntColumnConfig<boolean, boolean> | StringColumnConfig<boolean, boolean>) {
+  getColumnWidth(
+    colNum: number,
+    config:
+      | BigIntColumnConfig<boolean, boolean>
+      | StringColumnConfig<boolean, boolean>,
+  ) {
     let maxWidth = Math.max(
       (config.header ?? "").length,
       this.#footer && this.#footerRowConfig
-        ? this.#getCellValueAsString(this.#footer[colNum], this.#footerRowConfig[colNum]).length
-        : 0
+        ? this.#getCellValueAsString(
+          this.#footer[colNum],
+          this.#footerRowConfig[colNum],
+        ).length
+        : 0,
     );
 
     for (let r = 0; r < this.#rows.length; r++) {