@travetto/manifest 3.3.1 → 3.4.0-rc.0

package/README.md

@@ -19,7 +19,6 @@ This module aims to be the boundary between the file system and the code.  The m
    *  Class and Function Metadata
    *  Runtime Indexing
    *  Path Normalization
-   *  File Watching
 
 ## Project Manifesting
 The project manifest fulfills two main goals: Compile-time Support, and Runtime Knowledge of the project.
@@ -31,7 +30,7 @@ During the compilation process, the compiler needs to know every file that is el
 Additionally, once the code has been compiled (or even bundled after that), the executing process needs to know what files are available for loading, and any patterns necessary for knowing which files to load versus which ones to ignore. This allows for dynamic loading of modules/files without knowledge/access to the file system, and in a more performant manner.
 
 ## Manifest Delta
-During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L21) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
+During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L20) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
 
 ## Class and Function Metadata
 For the framework to work properly, metadata needs to be collected about files, classes and functions to uniquely identify them, with support for detecting changes during live reloads.  To achieve this, every `class` is decorated with an additional field of `Ⲑid`.  `Ⲑid` represents a computed id that is tied to the file/class combination. 
@@ -85,58 +84,7 @@ Once the manifest is created, the application runtime can now read this manifest
    *  Providing contextual information when provided a filename, import name, etc (e.g. logging, testing output)
 
 ## Path Normalization
-By default, all paths within the framework are assumed to be in a POSIX style, and all input paths are converted to the POSIX style.  This works appropriately within a Unix and a Windows environment.  This module offers up [path](https://github.com/travetto/travetto/tree/main/module/manifest/src/path.ts#L8) as an equivalent to [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library.  This allows for consistent behavior across all file-interactions, and also allows for easy analysis if [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library is ever imported.
-
-## File Watching
-The module also leverages [@parcel/watcher](https://www.npmjs.com/package/@parcel/watcher), to expose a single function of `watchFolders`. Only the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework") module packages [@parcel/watcher](https://www.npmjs.com/package/@parcel/watcher) as a direct dependency.  This means, that in production, by default all watch operations will fail with a missing dependency.
-
-**Code: Watch Configuration**
-```typescript
-export type WatchEvent = { action: 'create' | 'update' | 'delete', file: string, folder: string };
-
-export type WatchFolder = {
-  /**
-   * Source folder
-   */
-  src: string;
-  /**
-   * Target folder name, useful for deconstructing
-   */
-  target?: string;
-  /**
-   * Filter events
-   */
-  filter?: (ev: WatchEvent) => boolean;
-  /**
-   * Only look at immediate folder
-   */
-  immediate?: boolean;
-  /**
-   * List of top level folders to ignore
-   */
-  ignore?: string[];
-  /**
-   * If watching a folder that doesn't exist, should it be created?
-   */
-  createMissing?: boolean;
-  /**
-   * Include files that start with '.'
-   */
-  includeHidden?: boolean;
-};
-
-export type WatchStream = AsyncIterable<WatchEvent> & { close: () => Promise<void>, add: (item: WatchEvent | WatchEvent[]) => void };
-```
-
-This method allows for watching one or more folders, and registering a callback that will fire every time a file changes, and which of the registered folders it was triggered within. The return of the `watchFolders` is a cleanup method, that when invoked will remove and stop all watching behavior.
-
-**Code: Watch Configuration**
-```typescript
-export function watchFolders(
-  folders: string[] | WatchFolder[],
-  config: Omit<WatchFolder, 'src' | 'target'> = {}
-): WatchStream {
-```
+By default, all paths within the framework are assumed to be in a POSIX style, and all input paths are converted to the POSIX style.  This works appropriately within a Unix and a Windows environment.  This module offers up [path](https://github.com/travetto/travetto/tree/main/module/manifest/src/path.ts#L21) as an equivalent to [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library.  This allows for consistent behavior across all file-interactions, and also allows for easy analysis if [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library is ever imported.
 
 ## Anatomy of a Manifest
 
@@ -144,18 +92,19 @@ export function watchFolders(
 ```typescript
 {
   "generated": 1868155200000,
-  "moduleType": "commonjs",
-  "mainModule": "@travetto/manifest",
-  "mainFolder": "module/manifest",
   "workspacePath": "<generated>",
   "monoRepo": true,
-  "outputFolder": ".trv_output",
-  "toolFolder": ".trv_build",
-  "compilerFolder": ".trv_compiler",
   "packageManager": "npm",
+  "moduleType": "commonjs",
+  "outputFolder": ".trv/output",
+  "toolFolder": ".trv/tool",
+  "compilerFolder": ".trv/compiler",
+  "compilerUrl": "http://127.0.0.1:22154",
+  "frameworkVersion": "x.x.x",
+  "mainModule": "@travetto/manifest",
+  "mainFolder": "module/manifest",
   "version": "x.x.x",
   "description": "Support for project indexing, manifesting, along with file watching",
-  "frameworkVersion": "x.x.x",
   "modules": {
     "@travetto/manifest": {
       "main": true,
@@ -195,6 +144,7 @@ export function watchFolders(
         "src": [
           [ "src/delta.ts", "ts", 1868155200000 ],
           [ "src/dependencies.ts", "ts", 1868155200000 ],
+          [ "src/file.ts", "ts", 1868155200000 ],
           [ "src/manifest-index.ts", "ts", 1868155200000 ],
           [ "src/module.ts", "ts", 1868155200000 ],
           [ "src/package.ts", "ts", 1868155200000 ],
@@ -202,8 +152,7 @@ export function watchFolders(
           [ "src/root-index.ts", "ts", 1868155200000 ],
           [ "src/types.ts", "ts", 1868155200000 ],
           [ "src/typings.d.ts", "typings", 1868155200000 ],
-          [ "src/util.ts", "ts", 1868155200000 ],
-          [ "src/watch.ts", "ts", 1868155200000 ]
+          [ "src/util.ts", "ts", 1868155200000 ]
         ],
         "bin": [
           [ "bin/context.d.ts", "typings", 1868155200000 ],

package/__index__.ts

@@ -7,5 +7,5 @@ export * from './src/manifest-index';
 export * from './src/root-index';
 export * from './src/package';
 export * from './src/util';
-export * from './src/types';
-export * from './src/watch';
+export * from './src/file';
+export * from './src/types';

package/bin/context.js

@@ -1,131 +1,161 @@
 // @ts-check
 
 /**
- * @typedef {import('../src/types').Package} Pkg
+ * @typedef {import('../src/types').Package & { path:string }} Pkg
+ * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
  * @typedef {import('../src/types').ManifestContext} ManifestContext
  */
 import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
 
+/** @type {Record<string, Workspace>} */ const WS_ROOT = {};
+const TOOL_FOLDER = '.trv/tool';
+const COMPILER_FOLDER = '.trv/compiler';
+const OUTPUT_FOLDER = '.trv/output';
+
 /**
- * Returns the package.json
- * @param {string} inputFolder
- * @returns {Promise<Pkg>}
+ * Read package.json or return undefined if missing
+ * @param {string} dir
+ * @returns {Promise<Pkg|undefined>}
  */
-async function $getPkg(inputFolder) {
-  if (!inputFolder.endsWith('.json')) {
-    inputFolder = path.resolve(inputFolder, 'package.json');
-  }
-  return JSON.parse(await fs.readFile(inputFolder, 'utf8'));
+async function $readPackage(dir) {
+  dir = dir.endsWith('.json') ? path.dirname(dir) : dir;
+  return await fs.readFile(path.resolve(dir, 'package.json'), 'utf8')
+    .then(v => ({ ...JSON.parse(v), path: path.resolve(dir) }), () => undefined);
 }
 
-const WS_ROOT = {};
-
 /**
- * Get module root for a given folder
+ * Find package.json for a given folder
  * @param {string} dir
- * @return {Promise<string>}
+ * @return {Promise<Pkg>}
  */
-async function $getModuleRoot(dir) {
+async function $findPackage(dir) {
   let prev;
-  while (dir !== prev && !(await fs.stat(path.resolve(dir, 'package.json')).catch(() => false))) {
-    prev = dir;
-    dir = path.dirname(dir);
+  let pkg, curr = path.resolve(dir);
+  while (!pkg && curr !== prev) {
+    pkg = await $readPackage(curr);
+    [prev, curr] = [curr, path.dirname(curr)];
+  }
+  if (!pkg) {
+    throw new Error('Could not find a package.json');
+  } else {
+    return pkg;
   }
-  return dir;
-}
-
-
-/**
- * Get module name from a given file
- * @param {string} file
- * @return {Promise<string|void>}
- */
-async function $getModuleFromFile(file) {
-  return $getPkg(await $getModuleRoot(path.dirname(file))).then(v => v.name, () => { });
 }
 
 /**
  * Get workspace root
- * @return {Promise<string>}
+ * @return {Promise<Workspace>}
  */
-async function $getWorkspaceRoot(base = process.cwd()) {
-  if (base in WS_ROOT) {
-    return WS_ROOT[base];
-  }
-
+async function $resolveWorkspace(base = process.cwd()) {
+  if (base in WS_ROOT) { return WS_ROOT[base]; }
   let folder = base;
-  let prevFolder = '';
-  while (folder !== prevFolder) {
-    try {
-      const pkg = await $getPkg(folder);
-      if (!!pkg.workspaces || !!pkg.travetto?.isolated) {
-        return (WS_ROOT[base] = folder);
-      }
-    } catch { }
-    if (await fs.stat(path.resolve(folder, '.git')).catch(() => { })) {
+  let prev;
+  /** @type {Pkg|undefined} */
+  let prevPkg, pkg;
+
+  while (prev !== folder) {
+    [prev, prevPkg] = [folder, pkg];
+    pkg = await $readPackage(folder) ?? pkg;
+    if (
+      (pkg && (!!pkg.workspaces || !!pkg.travetto?.isolated)) || // if we have a monorepo root, or we are isolated
+      await fs.stat(path.resolve(folder, '.git')).catch(() => { }) // we made it to the source repo root
+    ) {
       break;
     }
-    prevFolder = folder;
     folder = path.dirname(folder);
   }
-  return WS_ROOT[base] = base;
-}
 
+  if (!pkg) {
+    throw new Error('Could not find a package.json');
+  }
+
+  return WS_ROOT[base] = {
+    ...pkg,
+    manager: await fs.stat(path.resolve(pkg.path, 'yarn.lock')).catch(() => { }) ? 'yarn' : 'npm',
+    resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
+    mono: !!pkg.workspaces || (!pkg.travetto?.isolated && !!prevPkg)  // Workspaces or nested projects
+  };
+}
 
 /**
- * Gets build context
- * @param {string} [folder]
- * @return {Promise<ManifestContext>}
+ * Get Compiler url
+ * @param {Workspace} ws
  */
-export async function getManifestContext(folder) {
-  const workspacePath = path.resolve(await $getWorkspaceRoot(folder));
-  const req = createRequire(`${workspacePath}/node_modules`);
+async function $getCompilerUrl(ws) {
+  let out = ws.travetto?.compilerUrl;
+  if (!out) {
+    const file = path.resolve(ws.path, ws.travetto?.toolFolder ?? TOOL_FOLDER, 'compiler.url');
+    // eslint-disable-next-line no-bitwise
+    const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+    out = `http://localhost:${port}`;
+    try { await fs.stat(file); } catch {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.writeFile(file, out, 'utf8');
+    }
+  }
+  return out.replace('localhost', '127.0.0.1');
+}
 
-  // If manifest specified via env var, and is a package name
+/**
+ * Resolve module folder
+ * @param {Workspace} workspace
+ * @param {string|undefined} folder
+ */
+async function $resolveModule(workspace, folder) {
+  let mod;
   if (!folder && process.env.TRV_MODULE) {
-    // If module is actually a file, try to detect
-    if (/[.](t|j)s$/.test(process.env.TRV_MODULE)) {
-      process.env.TRV_MODULE = await $getModuleFromFile(process.env.TRV_MODULE) ?? process.env.TRV_MODULE;
+    mod = process.env.TRV_MODULE;
+    if (/[.](t|j)s$/.test(mod)) { // Rewrite from file to module
+      process.env.TRV_MODULE = mod = await $findPackage(path.dirname(mod))
+        .then(v => v.name, () => '');
     }
+  }
+
+  if (mod) { // If module provided in lieu of folder
     try {
-      folder = path.dirname(req.resolve(`${process.env.TRV_MODULE}/package.json`));
+      folder = path.dirname(workspace.resolve(`${mod}/package.json`));
     } catch {
-      const workspacePkg = JSON.parse(await fs.readFile(path.resolve(workspacePath, 'package.json'), 'utf8'));
-      if (workspacePkg.name === process.env.TRV_MODULE) {
-        folder = workspacePath;
+      const workspacePkg = await $readPackage(workspace.path);
+      if (workspacePkg?.name === mod) {
+        folder = workspace.path;
       } else {
         throw new Error(`Unable to resolve location for ${folder}`);
       }
     }
   }
 
-  const mainPath = await $getModuleRoot(path.resolve(folder ?? '.'));
-  const { name: mainModule, workspaces, travetto, version, description } = (await $getPkg(mainPath));
-  const monoRepo = workspacePath !== mainPath || !!workspaces;
-  const outputFolder = travetto?.outputFolder ?? '.trv_output';
+  return $findPackage(folder ?? '.');
+}
 
-  const moduleType = (await $getPkg(workspacePath)).type ?? 'commonjs';
-  const mainFolder = mainPath === workspacePath ? '' : mainPath.replace(`${workspacePath}/`, '');
-  /** @type {'yarn'|'npm'} */
-  const packageManager = await fs.stat(path.resolve(workspacePath, 'yarn.lock')).then(() => 'yarn', () => 'npm');
+/**
+ * Gets build context
+ * @param {string} [folder]
+ * @return {Promise<ManifestContext>}
+ */
+export async function getManifestContext(folder) {
+  const workspace = await $resolveWorkspace(folder);
 
-  const { version: frameworkVersion } = JSON.parse(await fs.readFile(req.resolve('@travetto/manifest/package.json'), 'utf8'));
+  const [mod, framework, compilerUrl] = await Promise.all([
+    $resolveModule(workspace, folder),
+    $readPackage(workspace.resolve('@travetto/manifest/package.json')),
+    $getCompilerUrl(workspace),
+  ]);
 
-  const res = {
-    moduleType,
-    mainModule: mainModule ?? 'untitled', // When root package.json is missing a name
-    mainFolder,
-    workspacePath,
-    monoRepo,
-    outputFolder,
-    toolFolder: '.trv_build',
-    compilerFolder: '.trv_compiler',
-    packageManager,
-    version,
-    description,
-    frameworkVersion
+  return {
+    workspacePath: workspace.path,
+    monoRepo: workspace.mono,
+    packageManager: workspace.manager,
+    moduleType: workspace.type ?? 'commonjs',
+    outputFolder: workspace.travetto?.outputFolder ?? OUTPUT_FOLDER,
+    toolFolder: workspace.travetto?.toolFolder ?? TOOL_FOLDER,
+    compilerFolder: workspace.travetto?.compilerFolder ?? COMPILER_FOLDER,
+    compilerUrl,
+    frameworkVersion: framework?.version ?? '1.0.0',
+    mainModule: mod.name ?? 'untitled',
+    mainFolder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
+    version: mod.version,
+    description: mod.description
   };
-  return res;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "3.3.1",
+  "version": "3.4.0-rc.0",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",
@@ -30,14 +30,6 @@
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/manifest"
   },
-  "peerDependencies": {
-    "@parcel/watcher": "^2.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@parcel/watcher": {
-      "optional": true
-    }
-  },
   "travetto": {
     "displayName": "Manifest",
     "docBaseUrl": "https://github.com/travetto/travetto/tree/main"

package/src/delta.ts

@@ -1,12 +1,11 @@
-import fs from 'fs/promises';
-import path from 'path';
-
 import {
   ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
   ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
 } from './types';
 
 import { ManifestModuleUtil } from './module';
+import { ManifestFileUtil } from './file';
+import { path } from './path';
 
 type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
@@ -46,7 +45,7 @@ export class ManifestDeltaUtil {
     for (const el of Object.keys(left.files)) {
       const output = ManifestModuleUtil.sourceToOutputExt(`${outputFolder}/${left.outputFolder}/${el}`);
       const [, , leftTs] = left.files[el];
-      const stat = await fs.stat(output).catch(() => { });
+      const stat = await ManifestFileUtil.statFile(output);
       right.delete(ManifestModuleUtil.sourceToBlankExt(el));
 
       if (!stat) {

package/src/file.ts

@@ -0,0 +1,55 @@
+import os from 'os';
+import fs from 'fs/promises';
+import { readFileSync } from 'fs';
+
+import { path } from './path';
+import type { ManifestContext } from './types';
+
+export class ManifestFileUtil {
+  /**
+   * Write file and copy over when ready
+   */
+  static async bufferedFileWrite(file: string, content: string | object): Promise<string> {
+    const ext = path.extname(file);
+    const tempName = `${path.basename(file, ext)}.${process.ppid}.${process.pid}.${Date.now()}.${Math.random()}${ext}`;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const temp = path.resolve(os.tmpdir(), tempName);
+    await fs.writeFile(temp, typeof content === 'string' ? content : JSON.stringify(content), 'utf8');
+    await fs.copyFile(temp, file);
+    fs.unlink(temp);
+    return file;
+  }
+
+  /**
+   * Read as json
+   */
+  static async readAsJson<T = unknown>(file: string): Promise<T> {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+  }
+
+  /**
+   * Read as json, sync
+   */
+  static readAsJsonSync<T = unknown>(file: string): T {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  }
+
+  /**
+   * Stat file
+   */
+  static statFile(file: string): Promise<{ mtimeMs: number, ctimeMs: number } | undefined> {
+    return fs.stat(file).catch(() => undefined);
+  }
+
+  /**
+   * Resolve tool path for usage
+   */
+  static toolPath(ctx: ManifestContext | { manifest: ManifestContext }, rel: string, moduleSpecific = false): string {
+    ctx = 'manifest' in ctx ? ctx.manifest : ctx;
+    const parts = [rel];
+    if (moduleSpecific) {
+      parts.unshift('node_modules', ctx.mainModule);
+    }
+    return path.resolve(ctx.workspacePath, ctx.toolFolder, ...parts);
+  }
+}

package/src/module.ts

@@ -56,9 +56,6 @@ export class ManifestModuleUtil {
     const topFiles = new Set(mainSource ? [] : [...INDEX_FILES, 'package.json']);
     const out: string[] = [];
 
-    if (!fs.stat(folder).catch(() => false)) {
-      return out;
-    }
     const stack: [string, number][] = [[folder, 0]];
     while (stack.length) {
       const popped = stack.pop();

package/src/package.ts

@@ -1,10 +1,9 @@
-import { readFileSync } from 'fs';
-import fs from 'fs/promises';
 import { createRequire } from 'module';
 import { execSync } from 'child_process';
 
 import { ManifestContext, Package, PackageRel, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
 import { path } from './path';
+import { ManifestFileUtil } from './file';
 
 /**
  * Utilities for querying, traversing and reading package.json files.
@@ -99,10 +98,9 @@ export class PackageUtil {
     if (forceRead) {
       delete this.#cache[modulePath];
     }
-    const res = this.#cache[modulePath] ??= JSON.parse(readFileSync(
+    const res = this.#cache[modulePath] ??= ManifestFileUtil.readAsJsonSync(
       modulePath.endsWith('.json') ? modulePath : path.resolve(modulePath, 'package.json'),
-      'utf8'
-    ));
+    );
 
     res.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for npx execution
 
@@ -159,11 +157,10 @@ export class PackageUtil {
    */
   static async resolveWorkspaces(ctx: ManifestContext, rootPath: string): Promise<PackageWorkspaceEntry[]> {
     if (!this.#workspaces[rootPath]) {
-      await fs.mkdir(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true });
       const cache = path.resolve(ctx.workspacePath, ctx.outputFolder, 'workspaces.json');
       try {
-        return JSON.parse(await fs.readFile(cache, 'utf8'));
-      } catch {
+        return await ManifestFileUtil.readAsJson(cache);
+      } catch (err) {
         let out: PackageWorkspaceEntry[];
         switch (ctx.packageManager) {
           case 'npm': {
@@ -180,7 +177,7 @@ export class PackageUtil {
 
         this.#workspaces[rootPath] = out;
 
-        await fs.writeFile(cache, JSON.stringify(out), 'utf8');
+        await ManifestFileUtil.bufferedFileWrite(cache, out);
       }
     }
     return this.#workspaces[rootPath];

package/src/path.ts

@@ -9,7 +9,7 @@ const toPosix = (file: string): string => file.replaceAll('\\', '/');
 /**
  * Converts a given file name by replace all slashes, with platform dependent path separators
  */
-const toNative = (file: string): string => file.replaceAll('/', sep);
+const toNative = (file: string): string => file.replace(/[\\\/]+/g, sep);
 
 const cwd = (): string => toPosix(process.cwd());
 

package/src/types.ts

@@ -36,8 +36,9 @@ export type ManifestContext = {
   moduleType: 'module' | 'commonjs';
   packageManager: 'yarn' | 'npm';
   frameworkVersion: string;
-  description: string;
+  description?: string;
   version: string;
+  compilerUrl: string;
 };
 
 export type ManifestRoot = ManifestContext & {
@@ -83,6 +84,9 @@ export type Package = {
     docBaseUrl?: string;
     docOutputs?: string[];
     outputFolder?: string;
+    toolFolder?: string;
+    compilerFolder?: string;
+    compilerUrl?: string;
   };
   workspaces?: string[];
   private?: boolean;

package/src/util.ts

@@ -1,10 +1,7 @@
-import { readFileSync } from 'fs';
-import fs from 'fs/promises';
-import os from 'os';
-
 import { path } from './path';
 import { ManifestContext, ManifestRoot } from './types';
 import { ManifestModuleUtil } from './module';
+import { ManifestFileUtil } from './file';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -12,20 +9,6 @@ const MANIFEST_FILE = 'manifest.json';
  * Manifest utils
  */
 export class ManifestUtil {
-  /**
-   * Write file and copy over when ready
-   */
-  static async writeFileWithBuffer(file: string, content: string): Promise<string> {
-    const ext = path.extname(file);
-    const tempName = `${path.basename(file, ext)}.${process.ppid}.${process.pid}.${Date.now()}.${Math.random()}${ext}`;
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    const temp = path.resolve(os.tmpdir(), tempName);
-    await fs.writeFile(temp, content, 'utf8');
-    await fs.copyFile(temp, file);
-    fs.unlink(temp);
-    return file;
-  }
-
   /**
    * Build a manifest context
    * @param folder
@@ -75,7 +58,7 @@ export class ManifestUtil {
     if (!file.endsWith('.json')) {
       file = path.resolve(file, MANIFEST_FILE);
     }
-    const manifest: ManifestRoot = JSON.parse(readFileSync(file, 'utf8'));
+    const manifest: ManifestRoot = ManifestFileUtil.readAsJsonSync(file);
     // Support packaged environments, by allowing empty outputFolder
     if (!manifest.outputFolder) {
       manifest.outputFolder = path.cwd();
@@ -88,7 +71,7 @@ export class ManifestUtil {
    * Write manifest for a given context, return location
    */
   static writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<string> {
-    return this.writeFileWithBuffer(
+    return ManifestFileUtil.bufferedFileWrite(
       path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule, MANIFEST_FILE),
       JSON.stringify(manifest)
     );
@@ -102,8 +85,7 @@ export class ManifestUtil {
       location = path.resolve(location, MANIFEST_FILE);
     }
 
-    await fs.mkdir(path.dirname(location), { recursive: true });
-    await fs.writeFile(location, JSON.stringify(manifest), 'utf8');
+    await ManifestFileUtil.bufferedFileWrite(location, JSON.stringify(manifest));
 
     return location;
   }

package/src/watch.ts

@@ -1,205 +0,0 @@
-import { watch, Stats } from 'fs';
-import fs from 'fs/promises';
-
-import { path } from './path';
-
-async function getWatcher(): Promise<typeof import('@parcel/watcher')> {
-  try {
-    return await import('@parcel/watcher');
-  } catch (err) {
-    console.error('@parcel/watcher must be installed to use watching functionality');
-    throw err;
-  }
-}
-
-export type WatchEvent = { action: 'create' | 'update' | 'delete', file: string, folder: string };
-
-export type WatchFolder = {
-  /**
-   * Source folder
-   */
-  src: string;
-  /**
-   * Target folder name, useful for deconstructing
-   */
-  target?: string;
-  /**
-   * Filter events
-   */
-  filter?: (ev: WatchEvent) => boolean;
-  /**
-   * Only look at immediate folder
-   */
-  immediate?: boolean;
-  /**
-   * List of top level folders to ignore
-   */
-  ignore?: string[];
-  /**
-   * If watching a folder that doesn't exist, should it be created?
-   */
-  createMissing?: boolean;
-  /**
-   * Include files that start with '.'
-   */
-  includeHidden?: boolean;
-};
-
-export type WatchStream = AsyncIterable<WatchEvent> & { close: () => Promise<void>, add: (item: WatchEvent | WatchEvent[]) => void };
-
-const DEDUPE_THRESHOLD = 50;
-
-class Queue<X> implements AsyncIterator<X>, AsyncIterable<X> {
-  #queue: X[] = [];
-  #done = false;
-  #ready: Promise<void>;
-  #fire: (() => void);
-  #onClose: (() => (void | Promise<void>))[] = [];
-  #recentKeys = new Map<string, number>();
-
-  constructor() {
-    this.#ready = new Promise(r => this.#fire = r);
-  }
-
-  // Allow for iteration
-  [Symbol.asyncIterator](): AsyncIterator<X> { return this; }
-
-  async next(): Promise<IteratorResult<X>> {
-    while (!this.#done && !this.#queue.length) {
-      this.#recentKeys = new Map([...this.#recentKeys.entries()] // Cull before waiting
-        .filter(([, time]) => (Date.now() - time) < DEDUPE_THRESHOLD));
-      await this.#ready;
-      this.#ready = new Promise(r => this.#fire = r);
-    }
-    return { value: this.#queue.shift()!, done: this.#done };
-  }
-
-  add(item: X | X[]): void {
-    const now = Date.now();
-    for (const value of Array.isArray(item) ? item : [item]) {
-      const key = JSON.stringify(value);
-      if ((now - (this.#recentKeys.get(key) ?? 0)) > DEDUPE_THRESHOLD) {
-        this.#queue.push(value);
-        this.#recentKeys.set(key, now);
-        this.#fire();
-      }
-    }
-  }
-
-  registerOnClose(handler: () => (void | Promise<void>)): void {
-    this.#onClose.push(handler);
-  }
-
-  async close(): Promise<void> {
-    this.#done = true;
-    this.#fire();
-    await Promise.all(this.#onClose.map(x => x()));
-  }
-}
-
-/**
- * Watch immediate files for a given folder
- */
-async function watchFolderImmediate(queue: Queue<WatchEvent>, options: WatchFolder): Promise<void> {
-  const watchPath = path.resolve(options.src);
-  const watcher = watch(watchPath, { persistent: true, encoding: 'utf8' });
-  const lastStats: Record<string, Stats | undefined> = {};
-  const invalidFilter = (el: string): boolean =>
-    (el === '.' || el === '..' || (!options.includeHidden && el.startsWith('.')) || !!options.ignore?.includes(el));
-
-  for (const el of await fs.readdir(watchPath)) {
-    if (invalidFilter(el)) {
-      continue;
-    }
-    const file = path.resolve(watchPath, el);
-    lastStats[file] = await fs.stat(file);
-  }
-
-  const target = options.target ?? options.src;
-
-  watcher.on('change', async (type: string, file: string): Promise<void> => {
-    if (invalidFilter(file)) {
-      return;
-    }
-
-    file = path.resolve(watchPath, file);
-
-    const stat = await fs.stat(file).catch(() => undefined);
-    const prevStat = lastStats[file];
-    lastStats[file] = stat;
-
-    if (prevStat?.mtimeMs === stat?.mtimeMs) {
-      return;
-    }
-    let ev: WatchEvent;
-    if (prevStat && !stat) {
-      ev = { action: 'delete', file, folder: target };
-    } else if (!prevStat && stat) {
-      ev = { action: 'create', file, folder: target };
-    } else {
-      ev = { action: 'update', file, folder: target };
-    }
-    if (!options.filter || options.filter(ev)) {
-      queue.add(ev);
-    }
-  });
-
-  queue.registerOnClose(() => watcher.close());
-}
-
-/**
- * Watch recursive files for a given folder
- */
-async function watchFolderRecursive(queue: Queue<WatchEvent>, options: WatchFolder): Promise<void> {
-  const lib = await getWatcher();
-  const target = options.target ?? options.src;
-
-  if (await fs.stat(options.src).then(() => true, () => options.createMissing)) {
-    await fs.mkdir(options.src, { recursive: true });
-    const ignore = (await fs.readdir(options.src)).filter(x => x.startsWith('.') && x.length > 2);
-    const cleanup = await lib.subscribe(options.src, async (err, events) => {
-      for (const ev of events) {
-        const finalEv = { action: ev.type, file: path.toPosix(ev.path), folder: target };
-        if (ev.type !== 'delete') {
-          const stats = await fs.stat(finalEv.file);
-          if ((stats.ctimeMs - Date.now()) < DEDUPE_THRESHOLD) {
-            ev.type = 'create'; // Force create on newly stated files
-          }
-        }
-
-        if (ev.type === 'delete' && finalEv.file === options.src) {
-          return queue.close();
-        }
-        const isHidden = !options.includeHidden && finalEv.file.replace(target, '').includes('/.');
-        const matches = !isHidden && (!options.filter || options.filter(finalEv));
-        if (matches) {
-          queue.add(finalEv);
-        }
-      }
-    }, { ignore: [...ignore, ...options.ignore ?? []] });
-    queue.registerOnClose(() => cleanup.unsubscribe());
-  }
-}
-
-/**
- * Watch a series of folders
- * @param folders
- * @param onEvent
- * @param options
- */
-export function watchFolders(
-  folders: string[] | WatchFolder[],
-  config: Omit<WatchFolder, 'src' | 'target'> = {}
-): WatchStream {
-  const queue = new Queue<WatchEvent>();
-  for (const folder of folders) {
-    if (typeof folder === 'string') {
-      watchFolderRecursive(queue, { ...config, src: folder });
-    } else if (!folder.immediate) {
-      watchFolderRecursive(queue, { ...config, ...folder });
-    } else {
-      watchFolderImmediate(queue, { ...config, ...folder });
-    }
-  }
-  return queue;
-}