@dbx-tools/projen 0.6.8 → 0.6.10

package/index.ts

@@ -15,6 +15,7 @@ export * as packages from "./src/packages.ts";
 export * as pnpmWorkspace from "./src/pnpm-workspace.ts";
 export * as project from "./src/project.ts";
 export * as projectPredicate from "./src/project-predicate.ts";
+export * as publish from "./src/publish.ts";
 export * as release from "./src/release.ts";
 export * as scaffold from "./src/scaffold.ts";
 export * as tags from "./src/tags.ts";
@@ -22,75 +23,24 @@ export * as tsconfig from "./src/tsconfig.ts";
 export * as vite from "./src/vite.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
-export { generateBarrels } from "./src/barrels.ts";
-export { listGeneratedFiles, listNodeModulesDirs, removePaths } from "./src/clean.ts";
-export { generateCodegen } from "./src/codegen.ts";
 export { DBXToolsConfig } from "./src/dbx-tools-config.ts";
 export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
 export { resolvePkgRoot } from "./src/engine-root.ts";
-export { makeWritable, makeReadonly, isReadonly, header, stampGenerated } from "./src/generated.ts";
 export type { HeaderOpts } from "./src/generated.ts";
-export { create } from "./src/mixin.ts";
 export type { ConstructsMixin } from "./src/mixin.ts";
-export { moduleStatements } from "./src/module-exports.ts";
 export type { ModuleStatement, ModuleExport } from "./src/module-exports.ts";
-export { isTsoaController, generateOpenapi } from "./src/openapi.ts";
-export {
-  repoRoot,
-  DEFAULT_PACKAGE_ROOTS,
-  projectName,
-  toPosix,
-  isGeneratedFile,
-  isModuleFile,
-  DiscoveredPackage,
-  scanPackages,
-  readPackageManifest,
-  syncResynthPaths,
-  recordedPackages,
-  recordedRoots,
-} from "./src/packages.ts";
+export { repoRoot, DEFAULT_PACKAGE_ROOTS, DiscoveredPackage } from "./src/packages.ts";
 export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
 export type { Catalog, AllowBuilds, DBXToolsPNPMWorkspaceOptions } from "./src/pnpm-workspace.ts";
-export {
-  PackageIdentifier,
-  identifier,
-  applyCompilerOptions,
-  applyIncludes,
-  applyTasks,
-  applyExports,
-  addExports,
-  addPackageFiles,
-  srcModuleExports,
-  PROJEN_VERSION,
-  DBXToolsNodeProject,
-  DBXToolsTypeScriptProject,
-  taskScript,
-  applyToProjects,
-} from "./src/project.ts";
-export type {
-  DBXToolsProject,
-  DBXToolsProjectOptions,
-  DBXToolsTypeScriptProjectOptions,
-  ApplyToProjectsOptions,
-} from "./src/project.ts";
-export {
-  isProject,
-  isDBXToolsProject,
-  hasName,
-  hasIdentifierPackageName,
-  hasIdentifierName,
-  hasIdentifierScope,
-  hasTag,
-  hasPath,
-} from "./src/project-predicate.ts";
+export { PackageIdentifier, PROJEN_VERSION, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./src/project.ts";
+export type { DBXToolsProject, DBXToolsProjectOptions, DBXToolsTypeScriptProjectOptions, ApplyToProjectsOptions } from "./src/project.ts";
+export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.ts";
-export { runSynth } from "./src/scaffold.ts";
 export { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS } from "./src/tags.ts";
 export type { PackageTag } from "./src/tags.ts";
 export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
-export { ViteConfigFile } from "./src/vite.ts";
+export { DEFAULT_VITE_OVERRIDES, ViteConfigFile } from "./src/vite.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
-export { watchRoots, watchLoop } from "./src/watch.ts";
 export type { IgnoreGroupOptions } from "./src/watch.ts";

package/package.json

@@ -32,7 +32,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/barrels.ts

@@ -98,9 +98,19 @@ const BARREL_HEADER: HeaderOpts = {
   source: "the exporting modules in ./src",
 };
 
-/** `pnpm-workspace` -> `pnpmWorkspace`; nested paths join in camelCase. */
+/** `pnpm-workspace` -> `pnpmWorkspace`; `local-fs` -> `localFS` (`fs` -> `FS`). */
 function kebabToCamel(segment: string): string {
-  return segment.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+  const tokens = [...string.tokenizeWithOptions({ lowerCase: true, capitalize: true }, segment)];
+  if (tokens.length === 0) return segment;
+  const [first, ...rest] = tokens;
+  // Standalone acronym modules (`fs`, `ai`) stay lowercase so they match
+  // Node-style namespaces (`import * as fs`). Trailing / mid acronyms keep
+  // their override casing (`localFS`).
+  const head =
+    rest.length === 0 && first === first.toUpperCase()
+      ? first.toLowerCase()
+      : first.charAt(0).toLowerCase() + first.slice(1);
+  return head + rest.join("");
 }
 
 /** Derive a valid namespace identifier from a relocated barrel module path. */
@@ -134,9 +144,11 @@ function namespaceLines(content: string): { ns: string; modulePath: string }[] {
 /**
  * Append hoisted top-level re-exports for every export that is UNIQUE across the
  * package's modules - `export type { ... }` for types, `export { ... }` for
- * values. A name declared by two or more modules is ambiguous and left
- * namespace-only. `suppress` names (a hand-authored `exports.ts` surface) are
- * never hoisted so that file stays authoritative.
+ * non-function values (classes, consts, enums, …). `export function` names are
+ * never hoisted; they stay namespace-only (`posixPath.toPosix`). A name declared
+ * by two or more modules is ambiguous and left namespace-only. `suppress` names
+ * (a hand-authored `exports.ts` surface) are never hoisted so that file stays
+ * authoritative.
  */
 function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<string>): string {
   const namespaces = namespaceLines(content);
@@ -148,14 +160,15 @@ function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<strin
   const blocked = new Set<string>(suppress);
   for (const { ns } of namespaces) blocked.add(ns);
 
-  // Uniqueness is tallied over types AND values together - name -> { count,
-  // owning module } - so a name any two modules share stays namespace-only
-  // whichever kind each one is. `moduleExports` already dedupes within a module,
-  // so a count above one always means more than one module.
+  // Uniqueness is tallied over hoistable types AND values together - name ->
+  // { count, owning module }. Functions are excluded from hoisting and from
+  // this tally so they do not block a same-named type/class in another module.
   const seen = new Map<string, { count: number; modulePath: string }>();
   const perModule = new Map<string, ModuleExport[]>();
   for (const { modulePath } of namespaces) {
-    const exports = moduleExports(join(pkgDir, modulePath.replace(/^\.\//, "")));
+    const exports = moduleExports(join(pkgDir, modulePath.replace(/^\.\//, ""))).filter(
+      (e) => !e.isFunction,
+    );
     perModule.set(modulePath, exports);
     for (const { name } of exports) {
       const prior = seen.get(name);

package/src/module-exports.ts

@@ -16,7 +16,8 @@
  * Each name carries whether it is TYPE-only (`interface` / `type` alias /
  * `export type { ... }`), so the barrel can emit `export type { ... }` for it -
  * required under `isolatedModules`, where re-exporting a type through a value
- * `export { ... }` is a hard error (TS1205).
+ * `export { ... }` is a hard error (TS1205). `export function` names are marked
+ * `isFunction` so the barrel leaves them namespace-only.
  */
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -58,11 +59,16 @@ export function moduleStatements(file: string): readonly ModuleStatement[] {
 export interface ModuleExport {
   readonly name: string;
   readonly isType: boolean;
+  /** `export function` / `export async function` - never hoisted to the barrel. */
+  readonly isFunction: boolean;
 }
 
 /** Declaration node types that are inherently type-only. */
 const TYPE_DECLARATIONS = new Set(["TSInterfaceDeclaration", "TSTypeAliasDeclaration"]);
 
+/** Declaration node types that are functions (not hoisted). */
+const FUNCTION_DECLARATIONS = new Set(["FunctionDeclaration", "TSDeclareFunction"]);
+
 /**
  * Parse `file` and return its own top-level named exports (see the module
  * docstring for what's included). Returns `[]` on a read/parse error - a
@@ -102,18 +108,26 @@ export function moduleExports(file: string): ModuleExport[] {
     const decl = node.declaration;
     if (decl) {
       if (decl.id?.name) {
-        push({ name: decl.id.name, isType: stmtIsType || TYPE_DECLARATIONS.has(decl.type) });
+        push({
+          name: decl.id.name,
+          isType: stmtIsType || TYPE_DECLARATIONS.has(decl.type),
+          isFunction: FUNCTION_DECLARATIONS.has(decl.type),
+        });
       }
       for (const d of decl.declarations ?? []) {
         if (d.id?.type === "Identifier" && d.id.name) {
-          push({ name: d.id.name, isType: stmtIsType });
+          push({ name: d.id.name, isType: stmtIsType, isFunction: false });
         }
       }
     }
     for (const spec of node.specifiers ?? []) {
       const name = spec.exported?.name ?? spec.exported?.value;
       if (!name) continue;
-      push({ name, isType: stmtIsType || spec.exportKind === "type" });
+      push({
+        name,
+        isType: stmtIsType || spec.exportKind === "type",
+        isFunction: false,
+      });
     }
   }
   return [...byName.values()];