@travetto/manifest 3.0.0-rc.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ArcSine Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+<!-- This file was generated by @travetto/doc and should not be modified directly -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/manifest/DOC.ts and execute "npx trv doc" to rebuild -->
+# Manifest
+## Manifest support
+
+**Install: @travetto/manifest**
+```bash
+npm install @travetto/manifest
+```
+
+This module provides functionality for basic path functionality and common typings for manifests
+
+### Module Indexing
+The bootstrap process will also produce an index of all source files, which allows for fast in-memory scanning.  This allows for all the automatic discovery that is used within the framework.

package/__index__.ts

@@ -0,0 +1,11 @@
+/// <reference path="./src/typings.d.ts" />
+
+export * from './src/path';
+export * from './src/module';
+export * from './src/delta';
+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';

package/bin/context.d.ts

@@ -0,0 +1,10 @@
+import type { ManifestContext } from '../src/types';
+
+declare namespace ManifestBootstrap {
+  /**
+   * Get Context for building
+   */
+  function getManifestContext(folder?: string): Promise<ManifestContext>;
+}
+
+export = ManifestBootstrap;

package/bin/context.js

@@ -0,0 +1,116 @@
+// @ts-check
+
+/**
+ * @typedef {import('../src/types').Package} Pkg
+ * @typedef {import('../src/types').ManifestContext} ManifestContext
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
+
+/**
+ * Returns the package.json
+ * @param {string} inputFolder
+ * @returns {Promise<Pkg>}
+ */
+async function $getPkg(inputFolder) {
+  if (!inputFolder.endsWith('.json')) {
+    inputFolder = path.resolve(inputFolder, 'package.json');
+  }
+  return JSON.parse(await fs.readFile(inputFolder, 'utf8'));
+}
+
+const WS_ROOT = {};
+
+/**
+ * Get module name from a given file
+ * @param {string} file
+ * @return {Promise<string|void>}
+ */
+async function $getModuleFromFile(file) {
+  let dir = path.dirname(file);
+  let prev;
+  while (dir !== prev && !(await fs.stat(path.resolve(dir, 'package.json')).catch(() => false))) {
+    prev = dir;
+    dir = path.dirname(dir);
+  }
+  try {
+    return (await $getPkg(dir)).name;
+  } catch { }
+}
+
+/**
+ * Get workspace root
+ * @return {Promise<string>}
+ */
+async function $getWorkspaceRoot(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(() => { })) {
+      break;
+    }
+    prevFolder = folder;
+    folder = path.dirname(folder);
+  }
+  return WS_ROOT[base] = base;
+}
+
+
+/**
+ * Gets build context
+ * @param {string} [folder]
+ * @return {Promise<ManifestContext>}
+ */
+export async function getManifestContext(folder) {
+  const workspacePath = path.resolve(await $getWorkspaceRoot(folder));
+
+  // If manifest specified via env var, and is a package name
+  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;
+    }
+    const req = createRequire(`${workspacePath}/node_modules`);
+    try {
+      folder = path.dirname(req.resolve(`${process.env.TRV_MODULE}/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;
+      } else {
+        throw new Error(`Unable to resolve location for ${folder}`);
+      }
+    }
+  }
+
+  const mainPath = path.resolve(folder ?? '.');
+  const { name: mainModule, workspaces, travetto } = (await $getPkg(mainPath));
+  const monoRepo = workspacePath !== mainPath || !!workspaces;
+  const outputFolder = travetto?.outputFolder ?? '.trv_output';
+
+  const moduleType = (await $getPkg(workspacePath)).type ?? 'commonjs';
+  const mainFolder = mainPath === workspacePath ? '' : mainPath.replace(`${workspacePath}/`, '');
+
+  const res = {
+    moduleType,
+    mainModule,
+    mainFolder,
+    workspacePath,
+    monoRepo,
+    outputFolder,
+    toolFolder: '.trv_build',
+    compilerFolder: '.trv_compiler'
+  };
+  return res;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@travetto/manifest",
+  "version": "3.0.0-rc.10",
+  "description": "Manifest support",
+  "keywords": [
+    "path",
+    "package",
+    "manifest",
+    "travetto",
+    "typescript"
+  ],
+  "homepage": "https://travetto.io",
+  "license": "MIT",
+  "author": {
+    "email": "travetto.framework@gmail.com",
+    "name": "Travetto Framework"
+  },
+  "type": "module",
+  "files": [
+    "__index__.ts",
+    "bin",
+    "src",
+    "support"
+  ],
+  "main": "__index__.ts",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "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"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/delta.ts

@@ -0,0 +1,104 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import {
+  ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
+  ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
+} from './types';
+
+import { ManifestModuleUtil } from './module';
+
+type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
+type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
+export type DeltaEvent = { file: string, type: DeltaEventType, module: string };
+
+const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$package', 'doc']);
+const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+
+/**
+ * Produce delta for the manifest
+ */
+export class ManifestDeltaUtil {
+
+  static #getNewest(stat: { mtimeMs: number, ctimeMs: number }): number {
+    return Math.max(stat.mtimeMs, stat.ctimeMs);
+  }
+
+  /**
+   * Produce delta between two manifest modules, relative to an output folder
+   */
+  static async #deltaModules(ctx: ManifestContext, outputFolder: string, left: DeltaModule): Promise<DeltaEvent[]> {
+    const out: DeltaEvent[] = [];
+
+    const add = (file: string, type: DeltaEvent['type']): unknown =>
+      out.push({ file, module: left.name, type });
+
+    const root = `${ctx.workspacePath}/${ctx.outputFolder}/${left.outputFolder}`;
+    const right = new Set(
+      (await ManifestModuleUtil.scanFolder(root, left.main))
+        .filter(x => (x.endsWith('.ts') || x.endsWith('.js') || x.endsWith('package.json')))
+        .map(x => x.replace(`${root}/`, '').replace(/[.][tj]s$/, ''))
+    );
+
+    for (const el of Object.keys(left.files)) {
+      const output = `${outputFolder}/${left.outputFolder}/${el.replace(/[.]ts$/, '.js')}`;
+      const [, , leftTs] = left.files[el];
+      const stat = await fs.stat(output).catch(() => { });
+      right.delete(el.replace(/[.][tj]s$/, ''));
+
+      if (!stat) {
+        add(el, 'added');
+      } else {
+        const rightTs = this.#getNewest(stat);
+        if (leftTs > rightTs) {
+          add(el, 'changed');
+        }
+      }
+    }
+    // Deleted
+    for (const el of right) {
+      add(el, 'removed');
+    }
+    return out;
+  }
+
+  /**
+   * Collapse all files in a module
+   * @param {ManifestModule} m
+   * @returns {}
+   */
+  static #flattenModuleFiles(m: ManifestModule): Record<string, ManifestModuleFile> {
+    const out: Record<string, ManifestModuleFile> = {};
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    for (const key of Object.keys(m.files) as (ManifestModuleFolderType[])) {
+      if (!VALID_SOURCE_FOLDERS.has(key)) {
+        continue;
+      }
+      for (const [name, type, date] of m.files?.[key] ?? []) {
+        if (VALID_SOURCE_TYPE.has(type)) {
+          out[name] = [name, type, date];
+        }
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Produce delta between manifest root and the output folder
+   */
+  static async produceDelta(ctx: ManifestContext, manifest: ManifestRoot): Promise<DeltaEvent[]> {
+    const deltaLeft = Object.fromEntries(
+      Object.values(manifest.modules)
+        .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
+    );
+
+    const out: DeltaEvent[] = [];
+    const outputFolder = path.resolve(ctx.workspacePath, ctx.outputFolder);
+
+    for (const lMod of Object.values(deltaLeft)) {
+      out.push(...await this.#deltaModules(manifest, outputFolder, lMod));
+    }
+
+    return out;
+  }
+}

package/src/dependencies.ts

@@ -0,0 +1,163 @@
+import { PackageUtil } from './package';
+import { path } from './path';
+import { ManifestContext, ManifestProfile, PackageRel, PackageVisitor, PackageVisitReq } from './types';
+
+export type ModuleDep = {
+  version: string;
+  name: string;
+  main?: boolean;
+  mainSource?: boolean;
+  local?: boolean;
+  internal?: boolean;
+  sourcePath: string;
+  childSet: Map<string, Set<PackageRel>>;
+  parentSet: Set<string>;
+  profileSet: Set<ManifestProfile>;
+};
+
+/**
+ * Used for walking dependencies for collecting modules for the manifest
+ */
+export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
+
+  /**
+   * Get main patterns for detecting if a module should be treated as main
+   */
+  static getMainPatterns(mainModule: string, mergeModules: string[]): RegExp[] {
+    const groups: Record<string, string[]> = { [mainModule]: [] };
+    for (const el of mergeModules) {
+      if (el.includes('/')) {
+        const [grp, sub] = el.split('/');
+        (groups[`${grp}/`] ??= []).push(sub);
+      } else {
+        (groups[el] ??= []);
+      }
+    }
+
+    return Object.entries(groups)
+      .map(([root, subs]) => subs.length ? `${root}(${subs.join('|')})` : root)
+      .map(x => new RegExp(`^${x.replace(/[*]/g, '.*?')}$`));
+  }
+
+  constructor(public ctx: ManifestContext) { }
+
+  #mainPatterns: RegExp[] = [];
+
+  /**
+   * Initialize visitor, and provide global dependencies
+   */
+  async init(req: PackageVisitReq<ModuleDep>): Promise<PackageVisitReq<ModuleDep>[]> {
+    const pkg = PackageUtil.readPackage(req.sourcePath);
+    const workspacePkg = PackageUtil.readPackage(this.ctx.workspacePath);
+    const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(this.ctx, req.sourcePath)) : [];
+
+    this.#mainPatterns = ModuleDependencyVisitor.getMainPatterns(pkg.name, [
+      ...pkg.travetto?.mainSource ?? [],
+      // Add workspace folders, for tests and docs
+      ...workspaceModules.map(x => x.name)
+    ]);
+
+    const globals = [
+      ...(workspacePkg.travetto?.globalModules ?? []),
+      ...(pkg.travetto?.globalModules ?? [])
+    ]
+      .map(f => PackageUtil.resolvePackagePath(f));
+
+    const workspaceModuleDeps = workspaceModules
+      .map(entry => path.resolve(req.sourcePath, entry.sourcePath));
+
+    return [
+      ...globals,
+      ...workspaceModuleDeps
+    ].map(s => PackageUtil.packageReq(s, 'global'));
+  }
+
+  /**
+   * Is valid dependency for searching
+   */
+  valid(req: PackageVisitReq<ModuleDep>): boolean {
+    return req.sourcePath === path.cwd() || (
+      req.rel !== 'peer' &&
+      (!!req.pkg.travetto || req.pkg.private === true || !req.sourcePath.includes('node_modules') || req.rel === 'global')
+    );
+  }
+
+  /**
+   * Create dependency from request
+   */
+  create(req: PackageVisitReq<ModuleDep>): ModuleDep {
+    const { pkg: { name, version, travetto: { profiles = [] } = {}, ...pkg }, sourcePath } = req;
+    const profileSet = new Set<ManifestProfile>([
+      ...profiles ?? []
+    ]);
+    const main = name === this.ctx.mainModule;
+    const mainSource = main || this.#mainPatterns.some(x => x.test(name));
+    const internal = pkg.private === true;
+    const local = internal || mainSource || !sourcePath.includes('node_modules');
+
+    const dep = {
+      name, version, sourcePath, main, mainSource, local, internal,
+      parentSet: new Set([]), childSet: new Map(), profileSet
+    };
+
+    return dep;
+  }
+
+  /**
+   * Visit dependency
+   */
+  visit(req: PackageVisitReq<ModuleDep>, dep: ModuleDep): void {
+    const { parent } = req;
+    if (parent && dep.name !== this.ctx.mainModule) {
+      dep.parentSet.add(parent.name);
+      const set = parent.childSet.get(dep.name) ?? new Set();
+      parent.childSet.set(dep.name, set);
+      set.add(req.rel);
+    }
+  }
+
+  /**
+   * Propagate profile/relationship information through graph
+   */
+  complete(deps: Set<ModuleDep>): Set<ModuleDep> {
+    const mapping = new Map<string, { parent: Set<string>, child: Map<string, Set<PackageRel>>, el: ModuleDep }>();
+    for (const el of deps) {
+      mapping.set(el.name, { parent: new Set(el.parentSet), child: new Map(el.childSet), el });
+    }
+
+    const main = mapping.get(this.ctx.mainModule)!;
+
+    // Visit all direct dependencies and mark
+    for (const [name, relSet] of main.child) {
+      const childDep = mapping.get(name)!.el;
+      if (!relSet.has('dev')) {
+        childDep.profileSet.add('std');
+      }
+    }
+
+    while (mapping.size > 0) {
+      const toProcess = [...mapping.values()].filter(x => x.parent.size === 0);
+      if (!toProcess.length) {
+        throw new Error(`We have reached a cycle for ${[...mapping.keys()]}`);
+      }
+      // Propagate
+      for (const { el, child } of toProcess) {
+        for (const c of child.keys()) {
+          const { el: cDep, parent } = mapping.get(c)!;
+          parent.delete(el.name); // Remove from child
+          for (const prof of el.profileSet) {
+            cDep.profileSet.add(prof);
+          }
+        }
+      }
+      // Remove from mapping
+      for (const { el } of toProcess) {
+        mapping.delete(el.name);
+      }
+    }
+
+    // Color the main folder as std
+    main.el.profileSet.add('std');
+    return deps;
+  }
+}