@stacksjs/path 0.75.244 → 0.75.246

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { appPath, frameworkPath, projectPath, storagePath } from './project';
+import { appPath, frameworkDefaultsRoot, frameworkPath, projectPath, storagePath, usesVendoredDefaults } from './project';
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, parse, relative, resolve, sep, toNamespacedPath } from 'node:path';
 import type { ParsedPath } from 'node:path';
 /**
@@ -1220,6 +1220,8 @@ export declare interface Path {
   frameworkPath: (path?: string) => string
   browserPath: (path?: string) => string
   storagePath: (path?: string) => string
+  frameworkDefaultsRoot: (projectRoot?: string) => string
+  usesVendoredDefaults: (projectRoot?: string) => boolean
   functionsPath: (path?: string) => string
   gitPath: (path?: string) => string
   langPath: (path?: string) => string
@@ -1319,6 +1321,6 @@ export declare interface Path {
  *   comparison can say whether it is current.
  */
 export type DefaultsProvenance = 'not-applicable' | 'current' | 'stale' | 'unstamped';
-export { appPath, frameworkPath, isCompiledBinary, projectPath, storagePath } from './project';
+export { appPath, frameworkDefaultsRoot, frameworkPath, isCompiledBinary, isInstalledDefaultsRoot, linkPackagedDefaults, packagedDefaultsRoot, projectPath, storagePath, usesVendoredDefaults } from './project';
 export { resolveModulePath } from './module-resolution';
 export { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep, toNamespacedPath };

package/dist/index.js

@@ -2,21 +2,21 @@
 // src/index.ts
 import {
   existsSync as existsSync3,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync,
   readFileSync,
   readdirSync,
   readlinkSync,
-  realpathSync,
+  realpathSync as realpathSync2,
   renameSync,
-  rmSync,
+  rmSync as rmSync2,
   unlinkSync
 } from "fs";
 import os from "os";
 import {
   basename,
   delimiter,
-  dirname,
+  dirname as dirname2,
   extname,
   isAbsolute as isAbsolute2,
   join as join2,
@@ -30,8 +30,8 @@ import {
 import process2 from "process";
 
 // src/project.ts
-import { existsSync } from "fs";
-import { join, relative, resolve, sep } from "path";
+import { existsSync, lstatSync, realpathSync, rmSync, symlinkSync } from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
 import process from "process";
 var cachedCwd;
 var cachedProjectRoot = "";
@@ -73,8 +73,75 @@ function appPath(path, options) {
     return relative(options.cwd || process.cwd(), absolutePath);
   return absolutePath;
 }
+var VENDORED_DEFAULTS = "framework/defaults";
+var packagedDefaultsRoots = new Map;
+function isInstalledDefaultsRoot(path) {
+  return /[/\\]@stacksjs[/\\]defaults$/.test(path) && !/[/\\]install[/\\]cache[/\\]/.test(path);
+}
+function packagedDefaultsRoot(projectRoot = projectPath()) {
+  const cached = packagedDefaultsRoots.get(projectRoot);
+  if (cached)
+    return cached;
+  for (const dir of ["node_modules", "pantry"]) {
+    const candidate = join(projectRoot, dir, "@stacksjs", "defaults");
+    if (existsSync(join(candidate, "package.json"))) {
+      packagedDefaultsRoots.set(projectRoot, candidate);
+      return candidate;
+    }
+  }
+  if (cached === null)
+    return null;
+  let root = null;
+  try {
+    const resolved = dirname(Bun.resolveSync("@stacksjs/defaults/package.json", projectRoot));
+    if (isInstalledDefaultsRoot(resolved))
+      root = resolved;
+  } catch {}
+  packagedDefaultsRoots.set(projectRoot, root);
+  return root;
+}
+function usesVendoredDefaults(projectRoot = projectPath()) {
+  try {
+    return lstatSync(join(projectRoot, "storage", VENDORED_DEFAULTS)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function linkPackagedDefaults(projectRoot = projectPath()) {
+  const link = join(projectRoot, "storage", VENDORED_DEFAULTS);
+  let existing;
+  try {
+    existing = lstatSync(link);
+  } catch {}
+  if (existing && !existing.isSymbolicLink())
+    return false;
+  if (existing && existsSync(link))
+    return false;
+  if (!existsSync(dirname(link)))
+    return false;
+  const target = packagedDefaultsRoot(projectRoot);
+  if (!target)
+    return false;
+  try {
+    if (existing)
+      rmSync(link, { force: true });
+    symlinkSync(relative(realpathSync(dirname(link)), realpathSync(target)), link, "dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function frameworkDefaultsRoot(projectRoot = projectPath()) {
+  const vendored = join(projectRoot, "storage", VENDORED_DEFAULTS);
+  if (usesVendoredDefaults(projectRoot))
+    return vendored;
+  return packagedDefaultsRoot(projectRoot) ?? vendored;
+}
 function storagePath(path) {
-  return projectPath(`storage/${path || ""}`);
+  const sub = path || "";
+  if (sub === VENDORED_DEFAULTS || sub.startsWith(`${VENDORED_DEFAULTS}/`))
+    return resolve(frameworkDefaultsRoot(), `.${sub.slice(VENDORED_DEFAULTS.length)}`);
+  return projectPath(`storage/${sub}`);
 }
 function frameworkPath(path, options) {
   const absolutePath = storagePath(`framework/${path || ""}`);
@@ -417,7 +484,7 @@ function installedDefaultsVersion(projectRoot = projectPath()) {
   return manifestVersion(defaultsPackagePath(projectRoot));
 }
 function isInside(child, parent) {
-  const resolved = realpathSync(child);
+  const resolved = realpathSync2(child);
   return resolved === parent || resolved.startsWith(`${parent}${sep2}`);
 }
 function inspectDefaultsProvenance(projectRoot = projectPath()) {
@@ -425,10 +492,12 @@ function inspectDefaultsProvenance(projectRoot = projectPath()) {
   const packageRoot = defaultsPackagePath(projectRoot);
   if (!existsSync3(targetDefaults) || !existsSync3(join2(packageRoot, "package.json")))
     return notApplicable();
+  if (!usesVendoredDefaults(projectRoot))
+    return notApplicable();
   if (existsSync3(join2(projectRoot, "storage/framework/core/buddy/package.json")))
     return notApplicable();
   try {
-    if (!isInside(packageRoot, join2(realpathSync(projectRoot), "node_modules")))
+    if (!isInside(packageRoot, join2(realpathSync2(projectRoot), "node_modules")))
       return notApplicable();
   } catch {
     return notApplicable();
@@ -607,12 +676,12 @@ function mergeDirectoryInto(from, to) {
       renameSync(source, destination);
       continue;
     }
-    if (lstatSync(source).isDirectory() && lstatSync(destination).isDirectory()) {
+    if (lstatSync2(source).isDirectory() && lstatSync2(destination).isDirectory()) {
       mergeDirectoryInto(source, destination);
-      rmSync(source, { recursive: true, force: true });
+      rmSync2(source, { recursive: true, force: true });
       continue;
     }
-    rmSync(source, { recursive: true, force: true });
+    rmSync2(source, { recursive: true, force: true });
   }
 }
 function ensureRuntimeDirectories() {
@@ -621,14 +690,14 @@ function ensureRuntimeDirectories() {
     const legacyPath = projectPath(legacy);
     const targetPath = target();
     try {
-      const stats = lstatSync(legacyPath, { throwIfNoEntry: false });
+      const stats = lstatSync2(legacyPath, { throwIfNoEntry: false });
       if (!stats) {
         results.push({ legacy: legacyPath, target: targetPath, cleared: true });
         continue;
       }
       mkdirSync(targetPath, { recursive: true });
       if (stats.isSymbolicLink()) {
-        const pointsAtTarget = resolve3(dirname(legacyPath), readlinkSync(legacyPath)) === resolve3(targetPath);
+        const pointsAtTarget = resolve3(dirname2(legacyPath), readlinkSync(legacyPath)) === resolve3(targetPath);
         if (!pointsAtTarget) {
           results.push({ legacy: legacyPath, target: targetPath, cleared: false });
           continue;
@@ -636,9 +705,9 @@ function ensureRuntimeDirectories() {
         unlinkSync(legacyPath);
       } else if (stats.isDirectory()) {
         mergeDirectoryInto(legacyPath, targetPath);
-        rmSync(legacyPath, { recursive: true, force: true });
+        rmSync2(legacyPath, { recursive: true, force: true });
       } else {
-        rmSync(legacyPath, { force: true });
+        rmSync2(legacyPath, { force: true });
       }
       results.push({ legacy: legacyPath, target: targetPath, cleared: true });
     } catch {
@@ -714,6 +783,8 @@ var path = {
   frameworkPath,
   browserPath,
   storagePath,
+  frameworkDefaultsRoot,
+  usesVendoredDefaults,
   functionsPath,
   gitPath,
   langPath,
@@ -794,7 +865,7 @@ var path = {
   homeDir,
   basename,
   delimiter: () => delimiter,
-  dirname,
+  dirname: dirname2,
   extname,
   isAbsolute: isAbsolute2,
   join: join2,
@@ -846,7 +917,7 @@ export {
   delimiter,
   desktopPath,
   developmentPath,
-  dirname,
+  dirname2 as dirname,
   dnsPath,
   docsPath,
   emailPath,
@@ -862,6 +933,7 @@ export {
   featuresPath,
   findProjectPath,
   frameworkCloudPath,
+  frameworkDefaultsRoot,
   frameworkPath,
   frameworkRuntimePath,
   functionsPath,
@@ -872,6 +944,7 @@ export {
   installedDefaultsVersion,
   isAbsolute2 as isAbsolute,
   isCompiledBinary,
+  isInstalledDefaultsRoot,
   jobsPath,
   join2 as join,
   langPath,
@@ -879,6 +952,7 @@ export {
   libraryPackagePath,
   libsEntriesPath,
   libsPath,
+  linkPackagedDefaults,
   lintPath,
   listenersPath,
   loggingPath,
@@ -893,6 +967,7 @@ export {
   objectsPath,
   onboardingPath,
   ormPath,
+  packagedDefaultsRoot,
   paginationPath,
   path,
   pathPath,
@@ -959,6 +1034,7 @@ export {
   userNotificationsPath,
   userServerPath,
   userViewsPath,
+  usesVendoredDefaults,
   utilsPath,
   validationPath,
   viewsPath

package/dist/project.d.ts

@@ -2,5 +2,69 @@ import { relative } from 'node:path';
 export declare function isCompiledBinary(main?: string | undefined): boolean;
 export declare function projectPath(filePath?: string, options?: { relative: boolean }): string;
 export declare function appPath(path?: string, options?: { relative?: boolean, cwd?: string }): string;
+/**
+ * Whether a resolved `@stacksjs/defaults` is a copy the project installed.
+ *
+ * With none installed, Bun answers from its own auto-install cache
+ * (`~/.bun/install/cache/@stacksjs/defaults@x@@@1`, or
+ * `<repo>/pantry/install/cache/...` on CI): a release nobody declared. A test
+ * running in a temp directory then loaded that release's models.
+ */
+export declare function isInstalledDefaultsRoot(path: string): boolean;
+/**
+ * Where the installed `@stacksjs/defaults` lives for a project, or null when
+ * it is not installed. Resolved through `package.json` because the package
+ * publishes no `.` export, and memoised per project root once found: it
+ * cannot move without a reinstall, and this sits under every `storagePath()`
+ * call that names the defaults tree.
+ */
+export declare function packagedDefaultsRoot(projectRoot?: string): string | null;
+/**
+ * Whether this project keeps its own copy of the framework defaults in
+ * `storage/framework/defaults`: a real directory, not the link
+ * {@link linkPackagedDefaults} makes.
+ *
+ * A framework checkout always does (it is the source the package is built
+ * from), and so does an app created before the defaults moved into
+ * `node_modules`, or with `buddy new --vendor-defaults`. A new app does not:
+ * the 2,600-odd files are identical to the installed `@stacksjs/defaults`, so
+ * committing them only gave every project a copy to drift.
+ */
+export declare function usesVendoredDefaults(projectRoot?: string): boolean;
+/**
+ * Point `storage/framework/defaults` at the installed `@stacksjs/defaults`
+ * when the project does not vendor the tree.
+ *
+ * The link is gitignored, so it costs the repository nothing, and it keeps
+ * every path that names the tree directly working: a `~/storage/framework/
+ * defaults/...` import in an app's own template, an editor jumping to a
+ * default action, a tool that globs the views. `storagePath()` already falls
+ * back to the package without it; the link is for everything that does not
+ * ask `@stacksjs/path`.
+ *
+ * Idempotent and cheap (one lstat when the link is in place), so boot calls it.
+ * A vendored directory is never touched. A dangling link, left behind when
+ * `node_modules` moved, is replaced. Returns whether a link was written.
+ */
+export declare function linkPackagedDefaults(projectRoot?: string): boolean;
+/**
+ * The framework defaults tree this project runs: the vendored
+ * `storage/framework/defaults` when it is a real directory, otherwise the
+ * installed `@stacksjs/defaults` package. The vendored path is returned when
+ * neither exists, so a caller reports the path it has always reported.
+ *
+ * The package's own path even when the link to it is in place. The link is for
+ * people and tools; boot creates it, and a module resolved through a link made
+ * after the process started fails in Bun, whose resolver has already cached the
+ * directory as missing (`Unexpected while resolving package`, for every
+ * default model on a fresh clone's first boot).
+ */
+export declare function frameworkDefaultsRoot(projectRoot?: string): string;
+/**
+ * `storage/<path>`, except that `framework/defaults/...` follows
+ * {@link frameworkDefaultsRoot}. Every caller that names a default model,
+ * action, view or route through here (and through `frameworkPath`) therefore
+ * works the same whether the app vendors the tree or not.
+ */
 export declare function storagePath(path?: string): string;
 export declare function frameworkPath(path?: string, options?: { relative?: boolean, cwd?: string }): string;

package/dist/project.js

@@ -1,7 +1,7 @@
 // @bun
 // src/project.ts
-import { existsSync } from "fs";
-import { join, relative, resolve, sep } from "path";
+import { existsSync, lstatSync, realpathSync, rmSync, symlinkSync } from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
 import process from "process";
 var cachedCwd;
 var cachedProjectRoot = "";
@@ -43,8 +43,75 @@ function appPath(path, options) {
     return relative(options.cwd || process.cwd(), absolutePath);
   return absolutePath;
 }
+var VENDORED_DEFAULTS = "framework/defaults";
+var packagedDefaultsRoots = new Map;
+function isInstalledDefaultsRoot(path) {
+  return /[/\\]@stacksjs[/\\]defaults$/.test(path) && !/[/\\]install[/\\]cache[/\\]/.test(path);
+}
+function packagedDefaultsRoot(projectRoot = projectPath()) {
+  const cached = packagedDefaultsRoots.get(projectRoot);
+  if (cached)
+    return cached;
+  for (const dir of ["node_modules", "pantry"]) {
+    const candidate = join(projectRoot, dir, "@stacksjs", "defaults");
+    if (existsSync(join(candidate, "package.json"))) {
+      packagedDefaultsRoots.set(projectRoot, candidate);
+      return candidate;
+    }
+  }
+  if (cached === null)
+    return null;
+  let root = null;
+  try {
+    const resolved = dirname(Bun.resolveSync("@stacksjs/defaults/package.json", projectRoot));
+    if (isInstalledDefaultsRoot(resolved))
+      root = resolved;
+  } catch {}
+  packagedDefaultsRoots.set(projectRoot, root);
+  return root;
+}
+function usesVendoredDefaults(projectRoot = projectPath()) {
+  try {
+    return lstatSync(join(projectRoot, "storage", VENDORED_DEFAULTS)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function linkPackagedDefaults(projectRoot = projectPath()) {
+  const link = join(projectRoot, "storage", VENDORED_DEFAULTS);
+  let existing;
+  try {
+    existing = lstatSync(link);
+  } catch {}
+  if (existing && !existing.isSymbolicLink())
+    return false;
+  if (existing && existsSync(link))
+    return false;
+  if (!existsSync(dirname(link)))
+    return false;
+  const target = packagedDefaultsRoot(projectRoot);
+  if (!target)
+    return false;
+  try {
+    if (existing)
+      rmSync(link, { force: true });
+    symlinkSync(relative(realpathSync(dirname(link)), realpathSync(target)), link, "dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function frameworkDefaultsRoot(projectRoot = projectPath()) {
+  const vendored = join(projectRoot, "storage", VENDORED_DEFAULTS);
+  if (usesVendoredDefaults(projectRoot))
+    return vendored;
+  return packagedDefaultsRoot(projectRoot) ?? vendored;
+}
 function storagePath(path) {
-  return projectPath(`storage/${path || ""}`);
+  const sub = path || "";
+  if (sub === VENDORED_DEFAULTS || sub.startsWith(`${VENDORED_DEFAULTS}/`))
+    return resolve(frameworkDefaultsRoot(), `.${sub.slice(VENDORED_DEFAULTS.length)}`);
+  return projectPath(`storage/${sub}`);
 }
 function frameworkPath(path, options) {
   const absolutePath = storagePath(`framework/${path || ""}`);
@@ -54,8 +121,13 @@ function frameworkPath(path, options) {
 }
 export {
   appPath,
+  frameworkDefaultsRoot,
   frameworkPath,
   isCompiledBinary,
+  isInstalledDefaultsRoot,
+  linkPackagedDefaults,
+  packagedDefaultsRoot,
   projectPath,
-  storagePath
+  storagePath,
+  usesVendoredDefaults
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/path",
   "type": "module",
-  "version": "0.75.244",
+  "version": "0.75.246",
   "description": "The Stacks path.",
   "author": "Chris Breuer",
   "contributors": [