@hyperfrontend/project-scope 0.2.0 → 0.2.2

package/nx/index.esm.js

@@ -1,412 +1,15 @@
 import { join as join$1, resolve, parse as parse$1, dirname, basename, relative } from 'node:path';
 import { existsSync, readFileSync, statSync, lstatSync, readdirSync } from 'node:fs';
-
-/**
- * Safe copies of Error built-ins via factory functions.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides factory functions that use Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
- */
-// Capture references at module initialization time
-const _Error = globalThis.Error;
-const _Reflect$2 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Error using the captured Error constructor.
- * Use this instead of `new Error()`.
- *
- * @param message - Optional error message.
- * @param options - Optional error options.
- * @returns A new Error instance.
- */
-const createError = (message, options) => _Reflect$2.construct(_Error, [message, options]);
-
-/**
- * Safe copies of JSON built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/json
- */
-// Capture references at module initialization time
-const _JSON = globalThis.JSON;
-/**
- * (Safe copy) Converts a JavaScript Object Notation (JSON) string into an object.
- */
-const parse = _JSON.parse;
-/**
- * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
- */
-const stringify = _JSON.stringify;
-
-/**
- * Safe copies of Object built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
- */
-// Capture references at module initialization time
-const _Object = globalThis.Object;
-/**
- * (Safe copy) Prevents modification of existing property attributes and values,
- * and prevents the addition of new properties.
- */
-const freeze = _Object.freeze;
-/**
- * (Safe copy) Returns the names of the enumerable string properties and methods of an object.
- */
-const keys = _Object.keys;
-/**
- * (Safe copy) Returns an array of key/values of the enumerable own properties of an object.
- */
-const entries = _Object.entries;
-/**
- * (Safe copy) Returns an array of values of the enumerable own properties of an object.
- */
-const values = _Object.values;
-/**
- * (Safe copy) Adds one or more properties to an object, and/or modifies attributes of existing properties.
- */
-const defineProperties = _Object.defineProperties;
-
-/**
- * Safe copies of Array built-in static methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/array
- */
-// Capture references at module initialization time
-const _Array = globalThis.Array;
-/**
- * (Safe copy) Determines whether the passed value is an Array.
- */
-const isArray = _Array.isArray;
-
-/**
- * Safe copies of Console built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/console
- */
-// Capture references at module initialization time
-const _console = globalThis.console;
-/**
- * (Safe copy) Outputs a message to the console.
- */
-const log = _console.log.bind(_console);
-/**
- * (Safe copy) Outputs a warning message to the console.
- */
-const warn = _console.warn.bind(_console);
-/**
- * (Safe copy) Outputs an error message to the console.
- */
-const error = _console.error.bind(_console);
-/**
- * (Safe copy) Outputs an informational message to the console.
- */
-const info = _console.info.bind(_console);
-/**
- * (Safe copy) Outputs a debug message to the console.
- */
-const debug = _console.debug.bind(_console);
-/**
- * (Safe copy) Outputs a stack trace to the console.
- */
-_console.trace.bind(_console);
-/**
- * (Safe copy) Displays an interactive listing of the properties of a specified object.
- */
-_console.dir.bind(_console);
-/**
- * (Safe copy) Displays tabular data as a table.
- */
-_console.table.bind(_console);
-/**
- * (Safe copy) Writes an error message to the console if the assertion is false.
- */
-_console.assert.bind(_console);
-/**
- * (Safe copy) Clears the console.
- */
-_console.clear.bind(_console);
-/**
- * (Safe copy) Logs the number of times that this particular call to count() has been called.
- */
-_console.count.bind(_console);
-/**
- * (Safe copy) Resets the counter used with console.count().
- */
-_console.countReset.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console.
- */
-_console.group.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console that is initially collapsed.
- */
-_console.groupCollapsed.bind(_console);
-/**
- * (Safe copy) Exits the current inline group.
- */
-_console.groupEnd.bind(_console);
-/**
- * (Safe copy) Starts a timer with a name specified as an input parameter.
- */
-_console.time.bind(_console);
-/**
- * (Safe copy) Stops a timer that was previously started.
- */
-_console.timeEnd.bind(_console);
-/**
- * (Safe copy) Logs the current value of a timer that was previously started.
- */
-_console.timeLog.bind(_console);
-
-/**
- * Safe copies of Set built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/set
- */
-// Capture references at module initialization time
-const _Set = globalThis.Set;
-const _Reflect$1 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Set using the captured Set constructor.
- * Use this instead of `new Set()`.
- *
- * @param iterable - Optional iterable of values.
- * @returns A new Set instance.
- */
-const createSet = (iterable) => _Reflect$1.construct(_Set, iterable ? [iterable] : []);
-
-const registeredClasses = [];
-
-/**
- * Returns the data type of the target.
- * Uses native `typeof` operator, however, makes distinction between `null`, `array`, and `object`.
- * Also, when classes are registered via `registerClass`, it checks if objects are instance of any known registered class.
- *
- * @param target - The target to get the data type of.
- * @returns The data type of the target.
- */
-const getType = (target) => {
-    if (target === null)
-        return 'null';
-    const nativeDataType = typeof target;
-    if (nativeDataType === 'object') {
-        if (isArray(target))
-            return 'array';
-        for (const registeredClass of registeredClasses) {
-            if (target instanceof registeredClass)
-                return registeredClass.name;
-        }
-    }
-    return nativeDataType;
-};
-
-/**
- * Safe copies of Map built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
- */
-// Capture references at module initialization time
-const _Map = globalThis.Map;
-const _Reflect = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Map using the captured Map constructor.
- * Use this instead of `new Map()`.
- *
- * @param iterable - Optional iterable of key-value pairs.
- * @returns A new Map instance.
- */
-const createMap = (iterable) => _Reflect.construct(_Map, iterable ? [iterable] : []);
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that only executes the wrapped function if the condition function returns true.
- *
- * @param func - The function to be conditionally executed.
- * @param conditionFunc - A function that returns a boolean, determining if `func` should be executed.
- * @returns A wrapped version of `func` that executes conditionally.
- */
-function createConditionalExecutionFunction(func, conditionFunc) {
-    return function (...args) {
-        if (conditionFunc()) {
-            return func(...args);
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that silently ignores any errors thrown by the wrapped void function.
- * This function is specifically for wrapping functions that do not return a value (void functions).
- * Exceptions are swallowed without any logging or handling.
- *
- * @param func - The void function to be wrapped.
- * @returns A wrapped version of the input function that ignores errors.
- */
-function createErrorIgnoringFunction(func) {
-    return function (...args) {
-        try {
-            func(...args);
-        }
-        catch {
-            // Deliberately swallowing/ignoring the exception
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/**
- * A no-operation function (noop) that does nothing regardless of the arguments passed.
- * It is designed to be as permissive as possible in its typing without using the `Function` keyword.
- *
- * @param args - Any arguments passed to the function (ignored)
- */
-const noop = (...args) => {
-    // Intentionally does nothing
-};
-
-const logLevels = ['none', 'error', 'warn', 'log', 'info', 'debug'];
-const priority = {
-    error: 4,
-    warn: 3,
-    log: 2,
-    info: 1,
-    debug: 0,
-};
-/**
- * Validates whether a given string is a valid log level.
- *
- * @param level - The log level to validate
- * @returns True if the level is valid, false otherwise
- */
-function isValidLogLevel(level) {
-    return logLevels.includes(level);
-}
-/**
- * Creates a log level configuration manager for controlling logging behavior.
- * Provides methods to get, set, and evaluate log levels based on priority.
- *
- * @param level - The initial log level (defaults to 'error')
- * @returns A configuration object with log level management methods
- * @throws {Error} When the provided level is not a valid log level
- */
-function createLogLevelConfig(level = 'error') {
-    if (!isValidLogLevel(level)) {
-        throw createError('Cannot create log level configuration with a valid default log level');
-    }
-    const state = { level };
-    const getLogLevel = () => state.level;
-    const setLogLevel = (level) => {
-        if (!isValidLogLevel(level)) {
-            throw createError(`Cannot set value '${level}' level. Expected levels are ${logLevels}.`);
-        }
-        state.level = level;
-    };
-    const shouldLog = (level) => {
-        if (state.level === 'none' || level === 'none' || !isValidLogLevel(level)) {
-            return false;
-        }
-        return priority[level] >= priority[state.level];
-    };
-    return freeze({
-        getLogLevel,
-        setLogLevel,
-        shouldLog,
-    });
-}
-
-/**
- * Creates a logger instance with configurable log level filtering.
- * Each log function is wrapped to respect the current log level setting.
- *
- * @param error - Function to handle error-level logs (required)
- * @param warn - Function to handle warning-level logs (optional, defaults to noop)
- * @param log - Function to handle standard logs (optional, defaults to noop)
- * @param info - Function to handle info-level logs (optional, defaults to noop)
- * @param debug - Function to handle debug-level logs (optional, defaults to noop)
- * @returns A frozen logger object with log methods and level control
- * @throws {ErrorLevelFn} When any provided log function is invalid
- */
-function createLogger(error, warn = noop, log = noop, info = noop, debug = noop) {
-    if (notValidLogFn(error)) {
-        throw createError(notFnMsg('error'));
-    }
-    if (notValidLogFn(warn)) {
-        throw createError(notFnMsg('warn'));
-    }
-    if (notValidLogFn(log)) {
-        throw createError(notFnMsg('log'));
-    }
-    if (notValidLogFn(info)) {
-        throw createError(notFnMsg('info'));
-    }
-    if (notValidLogFn(debug)) {
-        throw createError(notFnMsg('debug'));
-    }
-    const { setLogLevel, getLogLevel, shouldLog } = createLogLevelConfig();
-    const wrapLogFn = (fn, level) => {
-        if (fn === noop)
-            return fn;
-        const condition = () => shouldLog(level);
-        return createConditionalExecutionFunction(createErrorIgnoringFunction(fn), condition);
-    };
-    return freeze({
-        error: wrapLogFn(error, 'error'),
-        warn: wrapLogFn(warn, 'warn'),
-        log: wrapLogFn(log, 'log'),
-        info: wrapLogFn(info, 'info'),
-        debug: wrapLogFn(debug, 'debug'),
-        setLogLevel,
-        getLogLevel,
-    });
-}
-/**
- * Validates whether a given value is a valid log function.
- *
- * @param fn - The value to validate
- * @returns True if the value is not a function (invalid), false if it is valid
- */
-function notValidLogFn(fn) {
-    return getType(fn) !== 'function' && fn !== noop;
-}
-/**
- * Generates an error message for invalid log function parameters.
- *
- * @param label - The name of the log function that failed validation
- * @returns A formatted error message string
- */
-function notFnMsg(label) {
-    return `Cannot create a logger when ${label} is not a function`;
-}
-
-createLogger(error, warn, log, info, debug);
+import { isArray } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify, parse } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.esm.js';
+import { freeze, entries, keys, defineProperties, values } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createLogger } from '../_dependencies/@hyperfrontend/logging/index.esm.js';
+import { createError } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+import { createMap } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.esm.js';
+import { isDirectory, exists } from '../_shared/core/fs/stat/index.esm.js';
+import { join } from '../_shared/core/path/join/index.esm.js';
 
 /**
  * Global log level registry.
@@ -446,6 +49,13 @@ function isSensitiveKey(key) {
  *
  * @param obj - Object to sanitize
  * @returns New object with sensitive values redacted
+ *
+ * @example Sanitizing sensitive data
+ * ```typescript
+ * const config = { apiKey: 'secret123', endpoint: 'https://api.example.com' }
+ * const safe = sanitize(config)
+ * // => { apiKey: '[REDACTED]', endpoint: 'https://api.example.com' }
+ * ```
  */
 function sanitize(obj) {
     if (obj === null || obj === undefined) {
@@ -496,7 +106,7 @@ function formatMessage(namespace, message, meta) {
  * @param options - Logger configuration options
  * @returns A configured scoped logger instance
  *
- * @example
+ * @example Creating a scoped logger
  * ```typescript
  * const logger = createScopedLogger('project-scope')
  * logger.setLogLevel('debug')
@@ -511,14 +121,11 @@ function formatMessage(namespace, message, meta) {
  */
 function createScopedLogger(namespace, options = {}) {
     const { level = 'error', sanitizeSecrets = true } = options;
-    // Create wrapper functions that add namespace prefix and sanitization
     const createLogFn = (baseFn) => (message, meta) => {
         const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
         baseFn(formatMessage(namespace, message, processedMeta));
     };
-    // Create base logger with wrapped functions
     const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
-    // Set initial log level (use global override if set)
     baseLogger.setLogLevel(level);
     const scopedLogger = freeze({
         error: (message, meta) => baseLogger.error(message, meta),
@@ -529,7 +136,6 @@ function createScopedLogger(namespace, options = {}) {
         setLogLevel: baseLogger.setLogLevel,
         getLogLevel: baseLogger.getLogLevel,
     });
-    // Register logger for global level management
     loggerRegistry.add(scopedLogger);
     return scopedLogger;
 }
@@ -537,7 +143,7 @@ function createScopedLogger(namespace, options = {}) {
  * Default logger instance for the project-scope library.
  * Use this for general logging within the library.
  *
- * @example
+ * @example Using the default logger
  * ```typescript
  * import { logger } from '@hyperfrontend/project-scope/core'
  *
@@ -555,6 +161,15 @@ createScopedLogger('project-scope:fs');
  * @param code - The category code for this type of filesystem failure
  * @param context - Additional context including path, operation, and cause
  * @returns A configured Error object with code and context properties
+ *
+ * @example Creating a file system error
+ * ```typescript
+ * throw createFileSystemError(
+ *   'Cannot read file',
+ *   'FS_READ_ERROR',
+ *   { path: './missing.txt', operation: 'read' }
+ * )
+ * ```
  */
 function createFileSystemError(message, code, context) {
     const error = createError(message);
@@ -570,6 +185,14 @@ function createFileSystemError(message, code, context) {
  * @param filePath - Path to file
  * @param encoding - File encoding (default: utf-8)
  * @returns File contents or null if file doesn't exist
+ *
+ * @example Reading file if it exists
+ * ```typescript
+ * const content = readFileIfExists('./optional-config.json')
+ * if (content) {
+ *   // File existed, use content
+ * }
+ * ```
  */
 function readFileIfExists(filePath, encoding = 'utf-8') {
     if (!existsSync(filePath)) {
@@ -587,6 +210,13 @@ function readFileIfExists(filePath, encoding = 'utf-8') {
  *
  * @param filePath - Path to JSON file
  * @returns Parsed JSON object or null if file doesn't exist or is invalid
+ *
+ * @example Reading JSON file if it exists
+ * ```typescript
+ * interface UserSettings { theme: string }
+ * const settings = readJsonFileIfExists<UserSettings>('./user-settings.json')
+ * const theme = settings?.theme ?? 'default'
+ * ```
  */
 function readJsonFileIfExists(filePath) {
     if (!existsSync(filePath)) {
@@ -601,56 +231,6 @@ function readJsonFileIfExists(filePath) {
     }
 }
 
-createScopedLogger('project-scope:fs:write');
-
-/**
- * Get file stats with error handling.
- *
- * @param filePath - Path to file
- * @param followSymlinks - Whether to follow symlinks (default: true)
- * @returns File stats or null if path doesn't exist
- */
-function getFileStat(filePath, followSymlinks = true) {
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const stat = followSymlinks ? statSync(filePath) : lstatSync(filePath);
-        return {
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-            isSymlink: stat.isSymbolicLink(),
-            size: stat.size,
-            created: stat.birthtime,
-            modified: stat.mtime,
-            accessed: stat.atime,
-            mode: stat.mode,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if path is a directory.
- *
- * @param dirPath - Path to check
- * @returns True if path is a directory
- */
-function isDirectory(dirPath) {
-    const stats = getFileStat(dirPath);
-    return stats?.isDirectory ?? false;
-}
-/**
- * Check if path exists.
- *
- * @param filePath - Path to check
- * @returns True if path exists
- */
-function exists(filePath) {
-    return existsSync(filePath);
-}
-
 const fsDirLogger = createScopedLogger('project-scope:fs:dir');
 /**
  * List immediate contents of a directory.
@@ -659,7 +239,7 @@ const fsDirLogger = createScopedLogger('project-scope:fs:dir');
  * @returns Array of entries with metadata for each file/directory
  * @throws {Error} If directory doesn't exist or isn't a directory
  *
- * @example
+ * @example Listing directory contents
  * ```typescript
  * import { readDirectory } from '@hyperfrontend/project-scope'
  *
@@ -700,17 +280,6 @@ function readDirectory(dirPath) {
     }
 }
 
-/**
- * Join path segments.
- * Uses platform-specific separators (e.g., / or \).
- *
- * @param paths - Path segments to join
- * @returns Joined path
- */
-function join(...paths) {
-    return join$1(...paths);
-}
-
 const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
 /**
  * Generic upward directory traversal.
@@ -719,6 +288,15 @@ const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
  * @param startPath - Starting directory
  * @param predicate - Function to test each directory
  * @returns First matching directory or null
+ *
+ * @example Finding directory containing README
+ * ```typescript
+ * // Find first directory containing a README
+ * const readmeDir = traverseUpward('./src/utils', (dir) =>
+ *   existsSync(join(dir, 'README.md'))
+ * )
+ * // => '/project' or null
+ * ```
  */
 function traverseUpward(startPath, predicate) {
     fsTraversalLogger.debug('Starting upward traversal', { startPath });
@@ -731,7 +309,6 @@ function traverseUpward(startPath, predicate) {
         }
         currentPath = dirname(currentPath);
     }
-    // Check root directory
     if (predicate(rootPath)) {
         fsTraversalLogger.debug('Upward traversal found match at root', { startPath, foundPath: rootPath });
         return rootPath;
@@ -745,6 +322,17 @@ function traverseUpward(startPath, predicate) {
  * @param startPath - Starting directory
  * @param markers - Array of marker file names to search for
  * @returns First directory containing any marker, or null
+ *
+ * @example Finding project root by marker files
+ * ```typescript
+ * // Find project root by looking for common marker files
+ * const projectRoot = locateByMarkers('./src/components', [
+ *   'package.json',
+ *   'nx.json',
+ *   'tsconfig.base.json'
+ * ])
+ * // => '/workspace/my-project'
+ * ```
  */
 function locateByMarkers(startPath, markers) {
     fsTraversalLogger.debug('Locating by markers', { startPath, markers });
@@ -755,6 +343,8 @@ function locateByMarkers(startPath, markers) {
     return result;
 }
 
+createScopedLogger('project-scope:fs:write');
+
 const packageLogger = createScopedLogger('project-scope:project:package');
 /**
  * Verifies that a value is an object with only string values,
@@ -824,6 +414,16 @@ function validatePackageJson(data) {
  *
  * @param projectPath - Project directory path or path to package.json
  * @returns Parsed package.json or null if not found
+ *
+ * @example Reading package.json if it exists
+ * ```typescript
+ * import { readPackageJsonIfExists } from '@hyperfrontend/project-scope'
+ *
+ * const pkg = readPackageJsonIfExists('/path/to/project')
+ * if (pkg) {
+ *   console.log('Found:', pkg.name)
+ * }
+ * ```
  */
 function readPackageJsonIfExists(projectPath) {
     const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : join$1(projectPath, 'package.json');
@@ -850,6 +450,15 @@ createScopedLogger('project-scope:root');
  * @param startPath - Starting path
  * @param markers - Files to search for
  * @returns Root directory path or null
+ *
+ * @example Finding root by marker files
+ * ```typescript
+ * import { findRootDirectory } from '@hyperfrontend/project-scope'
+ *
+ * // Find monorepo root by looking for nx.json or lerna.json
+ * const root = findRootDirectory('./libs/my-lib', ['nx.json', 'lerna.json'])
+ * // => '/path/to/monorepo'
+ * ```
  */
 function findRootDirectory(startPath, markers) {
     return locateByMarkers(startPath, markers);
@@ -870,7 +479,7 @@ const NX_PROJECT_FILE = 'project.json';
  * @param path - Directory path to check
  * @returns True if the directory contains nx.json or workspace.json
  *
- * @example
+ * @example Checking for NX workspace
  * ```typescript
  * import { isNxWorkspace } from '@hyperfrontend/project-scope'
  *
@@ -894,6 +503,15 @@ function isNxWorkspace(path) {
  *
  * @param path - Directory path to check
  * @returns True if the directory contains project.json
+ *
+ * @example Checking for NX project
+ * ```typescript
+ * import { isNxProject } from '@hyperfrontend/project-scope'
+ *
+ * if (isNxProject('./libs/my-lib')) {
+ *   console.log('This is an NX project')
+ * }
+ * ```
  */
 function isNxProject(path) {
     const isProject = exists(join$1(path, NX_PROJECT_FILE));
@@ -906,7 +524,7 @@ function isNxProject(path) {
  * @param startPath - Starting path to search from
  * @returns Workspace root path or null if not found
  *
- * @example
+ * @example Finding NX workspace root
  * ```typescript
  * import { findNxWorkspaceRoot } from '@hyperfrontend/project-scope'
  *
@@ -938,7 +556,6 @@ function detectNxVersion(workspacePath) {
     if (packageJson) {
         const nxVersion = packageJson.devDependencies?.['nx'] ?? packageJson.dependencies?.['nx'];
         if (nxVersion) {
-            // Strip semver range characters (^, ~, >=, etc.)
             return nxVersion.replace(/^[\^~>=<]+/, '');
         }
     }
@@ -959,6 +576,17 @@ function isIntegratedRepo(nxJson) {
  *
  * @param workspacePath - Workspace root path
  * @returns Workspace info or null if not an NX workspace
+ *
+ * @example Getting NX workspace information
+ * ```typescript
+ * import { getNxWorkspaceInfo } from '@hyperfrontend/project-scope'
+ *
+ * const info = getNxWorkspaceInfo('/path/to/monorepo')
+ * if (info) {
+ *   console.log('NX version:', info.version)
+ *   console.log('Apps dir:', info.workspaceLayout.appsDir)
+ * }
+ * ```
  */
 function getNxWorkspaceInfo(workspacePath) {
     nxLogger.debug('Getting NX workspace info', { workspacePath });
@@ -967,14 +595,12 @@ function getNxWorkspaceInfo(workspacePath) {
     }
     const nxJson = readJsonFileIfExists(join$1(workspacePath, 'nx.json'));
     if (!nxJson) {
-        // Check for workspace.json as fallback (older NX)
         const workspaceJson = readJsonFileIfExists(join$1(workspacePath, 'workspace.json'));
         if (!workspaceJson) {
             nxLogger.debug('No nx.json or workspace.json found', { workspacePath });
             return null;
         }
         nxLogger.debug('Using legacy workspace.json', { workspacePath });
-        // Create minimal nx.json from workspace.json
         return {
             root: workspacePath,
             version: detectNxVersion(workspacePath),
@@ -1006,98 +632,22 @@ function getNxWorkspaceInfo(workspacePath) {
     return info;
 }
 
-const devkitLogger = createScopedLogger('project-scope:nx:devkit');
-/** Cached load result to avoid repeated require attempts */
-let cachedResult = null;
-/**
- * Try to load `@nx/devkit` at runtime.
- * Uses dynamic require to avoid bundling `@nx/devkit` into our output.
- * Results are cached for subsequent calls.
- *
- * @returns DevkitLoadResult with availability status and devkit module or error
- */
-function tryLoadDevkit() {
-    if (cachedResult !== null) {
-        devkitLogger.debug('Returning cached devkit result', { available: cachedResult.available });
-        return cachedResult;
-    }
-    devkitLogger.debug('Attempting to load @nx/devkit');
-    try {
-        // Dynamic require to avoid bundling
-        const devkit = require('@nx/devkit');
-        devkitLogger.debug('@nx/devkit loaded successfully');
-        cachedResult = { available: true, devkit };
-    }
-    catch (error) {
-        devkitLogger.debug('@nx/devkit not available', { error: error instanceof Error ? error.message : String(error) });
-        cachedResult = {
-            available: false,
-            error: error instanceof Error ? error : createError(String(error)),
-        };
-    }
-    return cachedResult;
-}
-/**
- * Check if `@nx/devkit` is available.
- *
- * @returns true if devkit can be loaded, false otherwise
- */
-function isDevkitAvailable() {
-    return tryLoadDevkit().available;
-}
-/**
- * Get `@nx/devkit` module if available.
- * Throws if not available.
- *
- * @returns The `@nx/devkit` module with full type information
- * @throws {Error} If `@nx/devkit` is not available
- */
-function getDevkit() {
-    const result = tryLoadDevkit();
-    if (!result.available) {
-        throw createError('@nx/devkit is not available. Install it as a dependency or use standalone mode.');
-    }
-    return result.devkit;
-}
-/**
- * Execute function with `@nx/devkit` if available, otherwise execute fallback.
- * This pattern allows graceful degradation when `@nx/devkit` is not installed.
- *
- * @param ifAvailable - Function to execute if `@nx/devkit` is available
- * @param fallback - Function to execute if `@nx/devkit` is not available
- * @returns Result from whichever function was executed
- *
- * @example
- * ```typescript
- * const tree = withDevkit(
- *   (devkit) => devkit.createTree(),
- *   () => new FsTree(process.cwd())
- * )
- * ```
- */
-function withDevkit(ifAvailable, fallback) {
-    const result = tryLoadDevkit();
-    if (result.available && result.devkit) {
-        return ifAvailable(result.devkit);
-    }
-    return fallback();
-}
-/**
- * Reset the cached devkit load result.
- * Primarily useful for testing.
- *
- * @internal
- */
-function resetDevkitCache() {
-    cachedResult = null;
-}
-
 const nxConfigLogger = createScopedLogger('project-scope:nx:config');
 /**
  * Read project.json for an NX project.
  *
  * @param projectPath - Project directory path
  * @returns Parsed project.json or null if not found
+ *
+ * @example Reading NX project.json
+ * ```typescript
+ * import { readProjectJson } from '@hyperfrontend/project-scope'
+ *
+ * const config = readProjectJson('./libs/my-lib')
+ * if (config) {
+ *   console.log('Project:', config.name, 'Type:', config.projectType)
+ * }
+ * ```
  */
 function readProjectJson(projectPath) {
     const projectJsonPath = join$1(projectPath, NX_PROJECT_FILE);
@@ -1117,10 +667,17 @@ function readProjectJson(projectPath) {
  * @param projectPath - Project directory path
  * @param workspacePath - Workspace root path (for relative path calculation)
  * @returns Project configuration or null if not found
+ *
+ * @example Getting project configuration
+ * ```typescript
+ * import { getProjectConfig } from '@hyperfrontend/project-scope'
+ *
+ * const config = getProjectConfig('./libs/my-lib', '/workspace')
+ * // => { name: 'my-lib', root: 'libs/my-lib', projectType: 'library' }
+ * ```
  */
 function getProjectConfig(projectPath, workspacePath) {
     nxConfigLogger.debug('Getting project config', { projectPath, workspacePath });
-    // Try project.json first
     const projectJson = readProjectJson(projectPath);
     if (projectJson) {
         nxConfigLogger.debug('Using project.json config', { projectPath, name: projectJson.name });
@@ -1129,7 +686,6 @@ function getProjectConfig(projectPath, workspacePath) {
             root: projectJson.root ?? relative(workspacePath, projectPath),
         };
     }
-    // Try to infer from package.json nx field
     const packageJson = readPackageJsonIfExists(projectPath);
     if (packageJson && typeof packageJson['nx'] === 'object') {
         nxConfigLogger.debug('Using package.json nx field', { projectPath, name: packageJson.name });
@@ -1158,13 +714,11 @@ function scanForProjects(dirPath, workspacePath, projects, maxDepth, currentDept
     try {
         const entries = readDirectory(dirPath);
         for (const entry of entries) {
-            // Skip node_modules and hidden directories
             if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist') {
                 continue;
             }
             const fullPath = join$1(dirPath, entry.name);
             if (entry.isDirectory) {
-                // Check if this directory is an NX project
                 if (isNxProject(fullPath)) {
                     const config = getProjectConfig(fullPath, workspacePath);
                     if (config) {
@@ -1176,7 +730,6 @@ function scanForProjects(dirPath, workspacePath, projects, maxDepth, currentDept
                         });
                     }
                 }
-                // Recursively scan subdirectories
                 scanForProjects(fullPath, workspacePath, projects, maxDepth, currentDepth + 1);
             }
         }
@@ -1191,15 +744,23 @@ function scanForProjects(dirPath, workspacePath, projects, maxDepth, currentDept
  *
  * @param workspacePath - Workspace root path
  * @returns Map of project name to configuration
+ *
+ * @example Discovering all NX projects
+ * ```typescript
+ * import { discoverNxProjects } from '@hyperfrontend/project-scope'
+ *
+ * const projects = discoverNxProjects('/workspace')
+ * for (const [name, config] of projects) {
+ *   console.log(`${name}: ${config.projectType} at ${config.root}`)
+ * }
+ * ```
  */
 function discoverNxProjects(workspacePath) {
     const projects = createMap();
-    // Check for workspace.json (older NX format)
     const workspaceJson = readJsonFileIfExists(join$1(workspacePath, 'workspace.json'));
     if (workspaceJson?.projects) {
         for (const [name, config] of entries(workspaceJson.projects)) {
             if (typeof config === 'string') {
-                // Path reference to project directory
                 const projectPath = join$1(workspacePath, config);
                 const projectConfig = getProjectConfig(projectPath, workspacePath);
                 if (projectConfig) {
@@ -1207,18 +768,15 @@ function discoverNxProjects(workspacePath) {
                 }
             }
             else if (typeof config === 'object' && config !== null) {
-                // Inline config
                 projects.set(name, { name, ...config });
             }
         }
         return projects;
     }
-    // Scan for project.json files (newer NX format)
     const workspaceInfo = getNxWorkspaceInfo(workspacePath);
     const appsDir = workspaceInfo?.workspaceLayout.appsDir ?? 'apps';
     const libsDir = workspaceInfo?.workspaceLayout.libsDir ?? 'libs';
     const searchDirs = [appsDir, libsDir];
-    // Also check packages directory (common in some setups)
     if (exists(join$1(workspacePath, 'packages'))) {
         searchDirs.push('packages');
     }
@@ -1233,7 +791,6 @@ function discoverNxProjects(workspacePath) {
             }
         }
     }
-    // Also check root-level projects (standalone projects in monorepo root)
     if (isNxProject(workspacePath)) {
         const config = readProjectJson(workspacePath);
         if (config) {
@@ -1249,11 +806,19 @@ function discoverNxProjects(workspacePath) {
 }
 /**
  * Build a simple project graph from discovered projects.
- * For full graph capabilities, use `@nx/devkit`.
  *
  * @param workspacePath - Workspace root path
  * @param projects - Existing configuration map to skip auto-discovery
  * @returns NxProjectGraph with nodes and dependencies
+ *
+ * @example Building a simple project graph
+ * ```typescript
+ * import { buildSimpleProjectGraph } from '@hyperfrontend/project-scope'
+ *
+ * const graph = buildSimpleProjectGraph('/workspace')
+ * console.log('Projects:', Object.keys(graph.nodes))
+ * console.log('Dependencies:', graph.dependencies['my-app'])
+ * ```
  */
 function buildSimpleProjectGraph(workspacePath, projects) {
     const projectMap = projects ?? discoverNxProjects(workspacePath);
@@ -1266,10 +831,8 @@ function buildSimpleProjectGraph(workspacePath, projects) {
             data: config,
         };
         dependencies[name] = [];
-        // Add implicit dependencies
         if (config.implicitDependencies) {
             for (const dep of config.implicitDependencies) {
-                // Skip negative dependencies (those starting with !)
                 if (!dep.startsWith('!')) {
                     dependencies[name].push({
                         target: dep,
@@ -1282,5 +845,4 @@ function buildSimpleProjectGraph(workspacePath, projects) {
     return { nodes, dependencies };
 }
 
-export { NX_CONFIG_FILES, NX_PROJECT_FILE, buildSimpleProjectGraph, discoverNxProjects, findNxWorkspaceRoot, getDevkit, getNxWorkspaceInfo, getProjectConfig, isDevkitAvailable, isNxProject, isNxWorkspace, readProjectJson, resetDevkitCache, tryLoadDevkit, withDevkit };
-//# sourceMappingURL=index.esm.js.map
+export { NX_CONFIG_FILES, NX_PROJECT_FILE, buildSimpleProjectGraph, discoverNxProjects, findNxWorkspaceRoot, getNxWorkspaceInfo, getProjectConfig, isNxProject, isNxWorkspace, readProjectJson };