@travetto/manifest 5.0.1 → 5.0.2

package/README.md

@@ -134,6 +134,7 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
           [ "test/fixtures/simple.ts", "fixture", 1868155200000, "test" ]
         ],
         "src": [
+          [ "src/context.ts", "ts", 1868155200000 ],
           [ "src/delta.ts", "ts", 1868155200000 ],
           [ "src/dependencies.ts", "ts", 1868155200000 ],
           [ "src/file.ts", "ts", 1868155200000 ],
@@ -146,10 +147,6 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
           [ "src/types/context.ts", "ts", 1868155200000 ],
           [ "src/types/manifest.ts", "ts", 1868155200000 ],
           [ "src/types/package.ts", "ts", 1868155200000 ]
-        ],
-        "bin": [
-          [ "bin/context.d.ts", "typings", 1868155200000 ],
-          [ "bin/context.js", "js", 1868155200000 ]
         ]
       }
     }

package/__index__.ts

@@ -1,5 +1,4 @@
-/// <reference path="../runtime/src/global.d.ts" />
-
+export * from './src/context';
 export * from './src/module';
 export * from './src/delta';
 export * from './src/manifest-index';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "5.0.1",
+  "version": "5.0.2",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",
@@ -15,7 +15,6 @@
     "email": "travetto.framework@gmail.com",
     "name": "Travetto Framework"
   },
-  "type": "module",
   "files": [
     "__index__.ts",
     "bin",

package/{bin/context.js → src/context.ts}

@@ -1,25 +1,29 @@
-// @ts-check
-
-/**
- * @typedef {import('../src/types/package').Package & { path:string }} Pkg
- * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string, stripRoot: (file:string)=>string}} Workspace
- * @typedef {import('../src/types/context').ManifestContext} ManifestContext
- */
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 
-/** @type {Record<string, Workspace>} */ const WS_ROOT = {};
+import type { Package } from './types/package';
+import type { ManifestContext } from './types/context';
+
+type Pkg<T extends {} = {}> = Package & T & { path: string };
+type PathOp = (file: string) => string;
+type Workspace = Pkg<{
+  mono: boolean;
+  manager: 'yarn' | 'npm';
+  resolve: PathOp;
+  stripRoot: PathOp;
+}>;
+
 const TOOL_FOLDER = '.trv/tool';
 const COMPILER_FOLDER = '.trv/compiler';
 const OUTPUT_FOLDER = '.trv/output';
 
+const WS_ROOT: Record<string, Workspace> = {};
+
 /**
  * Read package.json or return undefined if missing
- * @param {string} dir
- * @returns {Pkg|undefined}
  */
-function $readPackage(dir) {
+function readPackage(dir: string): Pkg | undefined {
   dir = dir.endsWith('.json') ? path.dirname(dir) : dir;
   try {
     const v = readFileSync(path.resolve(dir, 'package.json'), 'utf8');
@@ -29,14 +33,12 @@ function $readPackage(dir) {
 
 /**
  * Find package.json for a given folder
- * @param {string} dir
- * @return {Pkg}
  */
-function $findPackage(dir) {
+function findPackage(dir: string): Pkg {
   let prev;
   let pkg, curr = path.resolve(dir);
   while (!pkg && curr !== prev) {
-    pkg = $readPackage(curr);
+    pkg = readPackage(curr);
     [prev, curr] = [curr, path.dirname(curr)];
   }
   if (!pkg) {
@@ -48,9 +50,8 @@ function $findPackage(dir) {
 
 /**
  * Get workspace root
- * @return {Workspace}
  */
-function $resolveWorkspace(base = process.cwd()) {
+function resolveWorkspace(base: string): Workspace {
   if (base in WS_ROOT) { return WS_ROOT[base]; }
   let folder = base;
   let prev;
@@ -59,7 +60,7 @@ function $resolveWorkspace(base = process.cwd()) {
 
   while (prev !== folder) {
     [prev, prevPkg] = [folder, pkg];
-    pkg = $readPackage(folder) ?? pkg;
+    pkg = readPackage(folder) ?? pkg;
     if (
       (pkg && (!!pkg.workspaces || !!pkg.travetto?.build?.isolated)) || // if we have a monorepo root, or we are isolated
       existsSync(path.resolve(folder, '.git')) // we made it to the source repo root
@@ -86,9 +87,8 @@ function $resolveWorkspace(base = process.cwd()) {
 
 /**
  * Get Compiler url
- * @param {Workspace} ws
  */
-function $getCompilerUrl(ws) {
+function getCompilerUrl(ws: Workspace): string {
   // eslint-disable-next-line no-bitwise
   const port = (Math.abs([...ws.path].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
   return `http://localhost:${port}`;
@@ -96,16 +96,14 @@ function $getCompilerUrl(ws) {
 
 /**
  * Resolve module folder
- * @param {Workspace} workspace
- * @param {string|undefined} folder
  */
-function $resolveModule(workspace, folder) {
+function resolveModule(workspace: Workspace, folder: string): Pkg {
   let mod;
   if (!folder && process.env.TRV_MODULE) {
     mod = process.env.TRV_MODULE;
-    if (/[.](t|j)sx?$/.test(mod)) { // Rewrite from file to module
+    if (/[.][cm]?(t|j)sx?$/.test(mod)) { // Rewrite from file to module
       try {
-        process.env.TRV_MODULE = mod = $findPackage(path.dirname(mod)).name;
+        process.env.TRV_MODULE = mod = findPackage(path.dirname(mod)).name;
       } catch {
         process.env.TRV_MODULE = mod = '';
       }
@@ -116,7 +114,7 @@ function $resolveModule(workspace, folder) {
     try {
       folder = path.dirname(workspace.resolve(`${mod}/package.json`));
     } catch {
-      const workspacePkg = $readPackage(workspace.path);
+      const workspacePkg = readPackage(workspace.path);
       if (workspacePkg?.name === mod) {
         folder = workspace.path;
       } else {
@@ -125,17 +123,15 @@ function $resolveModule(workspace, folder) {
     }
   }
 
-  return $findPackage(folder ?? '.');
+  return findPackage(folder ?? '.');
 }
 
 /**
  * Gets build context
- * @param {string} [folder]
- * @return {ManifestContext}
  */
-export function getManifestContext(folder) {
-  const workspace = $resolveWorkspace(folder);
-  const mod = $resolveModule(workspace, folder);
+export function getManifestContext(folder = process.cwd()): ManifestContext {
+  const workspace = resolveWorkspace(folder);
+  const mod = resolveModule(workspace, folder);
   const build = workspace.travetto?.build ?? {};
   const toolFolder = build.toolFolder ?? TOOL_FOLDER;
 
@@ -150,7 +146,7 @@ export function getManifestContext(folder) {
     },
     build: {
       compilerFolder: build.compilerFolder ?? COMPILER_FOLDER,
-      compilerUrl: build.compilerUrl ?? $getCompilerUrl(workspace),
+      compilerUrl: build.compilerUrl ?? getCompilerUrl(workspace),
       compilerModuleFolder: workspace.stripRoot(path.dirname(workspace.resolve('@travetto/compiler/package.json'))),
       outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
       toolFolder

package/src/delta.ts

@@ -12,8 +12,8 @@ type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFi
 export type DeltaEvent = { file: string, type: DeltaEventType, module: string, sourceFile: string };
 
 const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$package', 'doc']);
-const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
-const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>([...VALID_OUTPUT_TYPE, 'typings']);
+const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>([...VALID_SOURCE_TYPE, 'typings']);
 
 const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(o: T): K[] } & ObjectConstructor = Object;
 

package/src/module.ts

@@ -24,7 +24,9 @@ const INDEX_FILES = new Set(
 );
 
 const STD_TOP_FOLDERS = new Set(['src', 'bin', 'support']);
+const FULL_TOP_FOLDERS = new Set([...STD_TOP_FOLDERS, 'doc', 'test', 'resources']);
 const STD_TOP_FILES = new Set([...INDEX_FILES, 'package.json']);
+const FULL_TOP_FILES = new Set([...STD_TOP_FILES, 'DOC.tsx', 'README.md', 'LICENSE', 'DOC.html']);
 
 const SUPPORT_FILE_MAP: Record<string, ManifestModuleRole> = {
   transformer: 'compile',
@@ -32,7 +34,7 @@ const SUPPORT_FILE_MAP: Record<string, ManifestModuleRole> = {
   test: 'test',
   doc: 'doc',
   pack: 'build',
-  FILEld: 'build'
+  build: 'build'
 };
 
 const SUPPORT_FILE_RE = new RegExp(`^support[/](?<name>${Object.keys(SUPPORT_FILE_MAP).join('|')})[./]`);
@@ -48,8 +50,8 @@ export class ManifestModuleUtil {
   /**
    * Replace a source file's extension with a given value
    */
-  static #pathToExtension(inputFile: string, ext: string): string {
-    return inputFile.replace(/[.][tj]sx?$/, ext);
+  static #pathToExtension(sourceFile: string, ext: string): string {
+    return sourceFile.replace(/[.][cm]?[tj]sx?$/, ext);
   }
 
   /**
@@ -73,6 +75,9 @@ export class ManifestModuleUtil {
       path.resolve(ctx.workspace.path, ctx.build.toolFolder),
     ]);
 
+    const topFolders = full ? FULL_TOP_FOLDERS : STD_TOP_FOLDERS;
+    const topFiles = full ? FULL_TOP_FILES : STD_TOP_FILES;
+
     const stack: [string, number][] = [[folder, 0]];
     while (stack.length) {
       const popped = stack.pop();
@@ -85,21 +90,23 @@ export class ManifestModuleUtil {
       // Don't navigate into sub-folders with package.json's
       if (top !== folder && await fs.stat(`${top}/package.json`).catch(() => false)) {
         continue;
-      }
-      if (exclude.has(top)) {
+      } else if (exclude.has(top)) {
         continue;
       }
 
       for (const sub of await fs.readdir(top)) {
-        const valid = !sub.startsWith('.') && (depth > 0 || full);
-        const stat = await fs.stat(`${top}/${sub}`);
+        if (sub.startsWith('.') || sub === 'node_modules') {
+          continue;
+        }
+        const fullPath = `${top}/${sub}`;
+        const stat = await fs.stat(fullPath);
         if (stat.isFile()) {
-          if (valid || STD_TOP_FILES.has(sub)) {
-            out.push(`${top}/${sub}`);
+          if (depth > 0 || topFiles.has(sub)) {
+            out.push(fullPath);
           }
         } else {
-          if (!sub.includes('node_modules') && (valid || STD_TOP_FOLDERS.has(sub))) {
-            stack.push([`${top}/${sub}`, depth + 1]);
+          if (depth > 0 || topFolders.has(sub)) {
+            stack.push([fullPath, depth + 1]);
           }
         }
       }
@@ -167,7 +174,7 @@ export class ManifestModuleUtil {
         case 'doc':
         case 'resources':
         case 'support': return key;
-        default: return '$other';
+        default: throw new Error(`Unknown folder: ${key}`);
       }
     } else if (/^DOC[.]tsx?$/.test(moduleFile)) {
       return 'doc';
@@ -227,14 +234,20 @@ export class ManifestModuleUtil {
   /**
    * Get the output file name for a given input
    */
-  static withOutputExtension(inputFile: string): string {
-    return this.#pathToExtension(inputFile, '.js');
+  static withOutputExtension(sourceFile: string): string {
+    if (sourceFile.endsWith('.d.ts')) {
+      return sourceFile;
+    }
+    return this.#pathToExtension(sourceFile, '.js');
   }
 
   /**
    * Get the file without an extension
    */
-  static withoutSourceExtension(inputFile: string): string {
-    return this.#pathToExtension(inputFile, '');
+  static withoutSourceExtension(sourceFile: string): string {
+    if (sourceFile.endsWith('.d.ts')) {
+      return sourceFile;
+    }
+    return this.#pathToExtension(sourceFile, '');
   }
 }

package/src/path.ts

@@ -21,6 +21,7 @@ export const path: posix.PlatformPath & {
   dirname: file => posix.dirname(toPosix(file)),
   toNative,
   toPosix,
+  matchesGlob: (file, pattern) => posix.matchesGlob(toPosix(file), toPosix(pattern)),
   ...process.platform === 'win32' ? {
     resolve: (...args) => toPosix(native.resolve(cwd(), ...args.map(toPosix))),
     join: (root, ...args) => toPosix(native.join(toPosix(root), ...args.map(toPosix))),

package/src/types/common.ts

@@ -6,6 +6,6 @@ export type ManifestModuleFolderType =
   '$root' | '$index' | '$package' |
   'src' | 'bin' | 'support' | 'resources' | 'test' | 'doc' |
   'test/fixtures' | 'support/fixtures' | 'support/resources' |
-  '$other' | '$transformer';
+  '$transformer';
 
 export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';

package/src/types/context.ts

@@ -37,4 +37,4 @@ export type ManifestContext = {
     /** Version of the main module */
     version: string;
   };
-};
+};

package/bin/context.d.ts

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