@hyperfrontend/project-scope 0.2.1 → 0.2.3

package/core/path/index.esm.js

@@ -1,236 +1,9 @@
-import { join as join$1, posix, normalize, sep, isAbsolute as isAbsolute$1, relative, resolve, basename, dirname, extname, parse } from 'node:path';
 import { existsSync, realpathSync } from 'node:fs';
-
-/**
- * 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);
-}
-/**
- * Join path segments using POSIX separators (/).
- * Always uses forward slashes regardless of platform.
- *
- * @param paths - Path segments to join
- * @returns Joined path with forward slashes
- */
-function joinPosix(...paths) {
-    return posix.join(...paths);
-}
-
-/**
- * Normalize path separators to forward slashes.
- *
- * @param filePath - Path to normalize
- * @returns Normalized path with forward slashes
- */
-function normalizePath(filePath) {
-    if (!filePath)
-        return '';
-    const normalized = normalize(filePath);
-    return sep === '\\' ? normalized.replace(/\\/g, '/') : normalized;
-}
-/**
- * Convert path separators to forward slashes using POSIX style.
- * Resolves `.` and `..` segments for cross-platform configuration.
- *
- * @param filePath - The input path to convert
- * @returns Path with forward slashes and resolved segments
- */
-function normalizeToForwardSlashes(filePath) {
-    if (!filePath)
-        return '';
-    return normalize(filePath).split(sep).join('/');
-}
-/**
- * Convert path to use the operating system's native separator.
- *
- * @param filePath - The input path to convert
- * @returns Path with native separators (backslash on Windows, forward slash elsewhere)
- */
-function normalizeToNative(filePath) {
-    if (!filePath)
-        return '';
-    return normalize(filePath.replace(/[/\\]/g, sep));
-}
-/**
- * Strip any trailing forward or back slashes from a path.
- *
- * @param filePath - Path that may have trailing slashes
- * @returns Path with trailing slashes removed
- */
-function removeTrailingSlash(filePath) {
-    let i = filePath.length;
-    while (i > 0 && (filePath[i - 1] === '/' || filePath[i - 1] === '\\')) {
-        i--;
-    }
-    return filePath.slice(0, i);
-}
-/**
- * Append a forward slash to the path if not already present.
- *
- * @param filePath - Path to process
- * @returns Path with trailing forward slash
- */
-function ensureTrailingSlash(filePath) {
-    const normalized = removeTrailingSlash(filePath);
-    return normalized + '/';
-}
-
-/**
- * Check if path exists.
- *
- * @param filePath - Path to check
- * @returns True if path exists
- */
-function exists(filePath) {
-    return existsSync(filePath);
-}
-
-/**
- * Resolve path segments to an absolute path.
- *
- * @param segments - Path segments to resolve
- * @returns Resolved absolute path with normalized separators
- */
-function resolvePath(...segments) {
-    return normalizePath(resolve(...segments));
-}
-/**
- * Resolve path relative to workspace root.
- *
- * @param workspaceRoot - Workspace root directory
- * @param segments - Path segments relative to workspace
- * @returns Resolved absolute path with normalized separators
- */
-function resolveFromWorkspace(workspaceRoot, ...segments) {
-    return normalizePath(resolve(workspaceRoot, ...segments));
-}
-/**
- * Resolve symlinks to real path.
- *
- * @param filePath - Path to resolve
- * @returns Real path or null if path doesn't exist
- */
-function resolveRealPath(filePath) {
-    if (!exists(filePath)) {
-        return null;
-    }
-    try {
-        return normalizePath(realpathSync(filePath));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Compute the normalized path from source directory to target.
- *
- * @param from - Source path (base directory)
- * @param to - Target path to reach
- * @returns Relative path from source to target with forward slashes
- */
-function relativePath(from, to) {
-    return normalizePath(relative(from, to));
-}
-/**
- * Join path segments.
- *
- * @param segments - Path segments to join
- * @returns Joined path with normalized separators
- */
-function joinPath(...segments) {
-    return normalizePath(join$1(...segments));
-}
-/**
- * Check if path is absolute.
- *
- * @param filePath - Path to check
- * @returns True if path is absolute
- */
-function isAbsolute(filePath) {
-    return isAbsolute$1(filePath);
-}
-/**
- * Calculate offset from root (e.g., "../../../").
- *
- * @param filePath - Path to calculate offset for
- * @returns Relative offset path (e.g., "../../")
- */
-function offsetFromRoot(filePath) {
-    const segments = normalizePath(filePath).split('/').filter(Boolean);
-    if (segments.length === 0)
-        return '';
-    return segments.map(() => '..').join('/') + '/';
-}
-
-/**
- * Split path into segments.
- *
- * @param filePath - Path to split
- * @returns Array of path segments
- */
-function pathSegments(filePath) {
-    return filePath.split(/[/\\]/).filter((segment) => segment.length > 0);
-}
-/**
- * Get basename of path.
- *
- * @param filePath - Path to extract basename from
- * @param ext - Optional extension to strip
- * @returns Basename of path
- */
-function getBasename(filePath, ext) {
-    return basename(filePath, ext);
-}
-/**
- * Get directory name of path.
- *
- * @param filePath - Path to extract directory from
- * @returns Directory name
- */
-function getDirname(filePath) {
-    return normalizePath(dirname(filePath));
-}
-/**
- * Get file extension (including dot).
- *
- * @param filePath - Path to extract extension from
- * @returns Extension including dot (e.g., '.ts')
- */
-function getExtension(filePath) {
-    return extname(filePath);
-}
-/**
- * Get filename without extension.
- *
- * @param filePath - Path to extract name from
- * @returns Filename without extension
- */
-function getFileNameWithoutExtension(filePath) {
-    const parsed = parse(filePath);
-    return parsed.name;
-}
-/**
- * Parse path into components.
- *
- * @param filePath - Path to parse
- * @returns Parsed path components
- */
-function parsePath(filePath) {
-    const parsed = parse(filePath);
-    return {
-        root: parsed.root,
-        dir: normalizePath(parsed.dir),
-        base: parsed.base,
-        ext: parsed.ext,
-        name: parsed.name,
-    };
-}
-
-export { ensureTrailingSlash, getBasename, getDirname, getExtension, getFileNameWithoutExtension, isAbsolute, join, joinPath, joinPosix, normalizePath, normalizeToForwardSlashes, normalizeToNative, offsetFromRoot, parsePath, pathSegments, relativePath, removeTrailingSlash, resolveFromWorkspace, resolvePath, resolveRealPath };
-//# sourceMappingURL=index.esm.js.map
+import { normalize, sep, resolve, join as join$1, posix, isAbsolute as isAbsolute$1, relative, basename, dirname, extname, parse } from 'node:path';
+import { normalizePath, normalizeToForwardSlashes, normalizeToNative, removeTrailingSlash, ensureTrailingSlash } from '../../_shared/core/path/normalize/index.esm.js';
+import { isWithinRoot } from '../../_shared/core/path/confine/index.esm.js';
+import { join, joinPosix } from '../../_shared/core/path/join/index.esm.js';
+import { resolvePath, resolveFromWorkspace, resolveRealPath, relativePath, joinPath, isAbsolute, offsetFromRoot } from '../../_shared/core/path/resolve/index.esm.js';
+import { pathSegments, getBasename, getDirname, getExtension, getFileNameWithoutExtension, parsePath } from '../../_shared/core/path/segments/index.esm.js';
+
+export { ensureTrailingSlash, getBasename, getDirname, getExtension, getFileNameWithoutExtension, isAbsolute, isWithinRoot, join, joinPath, joinPosix, normalizePath, normalizeToForwardSlashes, normalizeToNative, offsetFromRoot, parsePath, pathSegments, relativePath, removeTrailingSlash, resolveFromWorkspace, resolvePath, resolveRealPath };

package/core/platform/index.cjs.js

@@ -1,218 +1,10 @@
 'use strict';
 
-var node_fs = require('node:fs');
-var node_os = require('node:os');
-var node_path = require('node:path');
-
-/**
- * Cached platform info (computed once).
- */
-let cachedPlatformInfo = null;
-/**
- * Cached case sensitivity result.
- */
-let cachedCaseSensitive = null;
-/**
- * Detect if file system is case sensitive.
- *
- * @returns True if file system is case-sensitive
- */
-function detectCaseSensitivity() {
-    if (cachedCaseSensitive !== null) {
-        return cachedCaseSensitive;
-    }
-    if (process.platform === 'win32') {
-        cachedCaseSensitive = false;
-        return false;
-    }
-    if (process.platform === 'darwin') {
-        cachedCaseSensitive = false;
-        return false;
-    }
-    let secureTestDir = null;
-    try {
-        secureTestDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'case-sensitivity-test-'));
-        const testFile = node_path.join(secureTestDir, 'A');
-        const testFileLower = node_path.join(secureTestDir, 'a');
-        node_fs.writeFileSync(testFile, '');
-        cachedCaseSensitive = !node_fs.existsSync(testFileLower);
-        node_fs.unlinkSync(testFile);
-    }
-    catch {
-        cachedCaseSensitive = true;
-    }
-    finally {
-        if (secureTestDir) {
-            try {
-                node_fs.rmdirSync(secureTestDir);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    return cachedCaseSensitive;
-}
-/**
- * Check if file system is case-sensitive.
- *
- * @returns True if file system is case-sensitive
- */
-function isCaseSensitiveFs() {
-    return detectCaseSensitivity();
-}
-/**
- * Get comprehensive platform information.
- *
- * @returns Platform information object (cached after first call)
- */
-function getPlatformInfo() {
-    if (cachedPlatformInfo) {
-        return cachedPlatformInfo;
-    }
-    const os = node_os.platform();
-    const archInfo = node_os.arch();
-    let osName;
-    switch (os) {
-        case 'win32':
-            osName = 'win32';
-            break;
-        case 'darwin':
-            osName = 'darwin';
-            break;
-        case 'linux':
-            osName = 'linux';
-            break;
-        case 'freebsd':
-            osName = 'freebsd';
-            break;
-        case 'sunos':
-            osName = 'sunos';
-            break;
-        case 'aix':
-            osName = 'aix';
-            break;
-        default:
-            osName = 'other';
-    }
-    cachedPlatformInfo = {
-        os: osName,
-        arch: archInfo,
-        nodeVersion: process.versions.node,
-        isWindows: osName === 'win32',
-        isMac: osName === 'darwin',
-        isLinux: osName === 'linux',
-        caseSensitive: detectCaseSensitivity(),
-        pathSeparator: osName === 'win32' ? '\\' : '/',
-        lineEnding: osName === 'win32' ? '\r\n' : '\n',
-    };
-    return cachedPlatformInfo;
-}
-/**
- * Detect current platform.
- *
- * @returns Platform information object
- */
-function detectPlatform() {
-    return getPlatformInfo();
-}
-/**
- * Check if running on Windows.
- *
- * @returns True if running on Windows
- */
-function isWindows() {
-    return process.platform === 'win32';
-}
-/**
- * Check if running on macOS.
- *
- * @returns True if running on macOS
- */
-function isMac() {
-    return process.platform === 'darwin';
-}
-/**
- * Check if running on Linux.
- *
- * @returns True if running on Linux
- */
-function isLinux() {
-    return process.platform === 'linux';
-}
-
-/** Unix line ending */
-const LF = '\n';
-/** Windows line ending */
-const CRLF = '\r\n';
-/**
- * Get platform-appropriate line ending.
- *
- * @returns Line ending for current platform
- */
-function getLineEnding() {
-    return isWindows() ? CRLF : LF;
-}
-/**
- * Get platform-appropriate path separator.
- *
- * @returns Path separator for current platform
- */
-function getPathSeparator() {
-    return isWindows() ? '\\' : '/';
-}
-/**
- * Normalize line endings in content.
- *
- * @param content - Content to normalize
- * @param style - Target line ending style ('lf', 'crlf', or 'auto' for platform default)
- * @returns Content with normalized line endings
- */
-function normalizeLineEndings(content, style = 'lf') {
-    let target;
-    if (style === 'auto') {
-        target = isWindows() ? CRLF : LF;
-    }
-    else {
-        target = style === 'crlf' ? CRLF : LF;
-    }
-    const normalized = content.replace(/\r\n/g, LF).replace(/\r/g, LF);
-    if (target === LF) {
-        return normalized;
-    }
-    return normalized.replace(/\n/g, target);
-}
-/**
- * Detect line ending style used in content.
- *
- * @param content - Content to analyze
- * @returns Detected line ending style
- */
-function detectLineEnding(content) {
-    const hasCRLF = content.includes(CRLF);
-    const hasLFOnly = content.includes('\n') && content.replace(/\r\n/g, '').includes('\n');
-    if (hasCRLF && hasLFOnly)
-        return 'mixed';
-    if (hasCRLF)
-        return 'crlf';
-    if (content.includes('\n'))
-        return 'lf';
-    return 'none';
-}
-/**
- * Compare paths with case sensitivity awareness.
- *
- * @param path1 - First path
- * @param path2 - Second path
- * @returns True if paths are equal (respecting case sensitivity)
- */
-function pathsEqual(path1, path2) {
-    const caseSensitive = detectCaseSensitivity();
-    if (caseSensitive) {
-        return path1 === path2;
-    }
-    return path1.toLowerCase() === path2.toLowerCase();
-}
+const node_fs = require('node:fs');
+const node_os = require('node:os');
+const node_path = require('node:path');
+const { detectCaseSensitivity, isCaseSensitiveFs, getPlatformInfo, detectPlatform, isWindows } = require('../../_shared/core/platform/detect/index.cjs.js');
+const { LF, CRLF, getLineEnding, getPathSeparator, normalizeLineEndings, detectLineEnding, pathsEqual } = require('../../_shared/core/platform/line-endings/index.cjs.js');
 
 exports.CRLF = CRLF;
 exports.LF = LF;
@@ -223,9 +15,6 @@ exports.getLineEnding = getLineEnding;
 exports.getPathSeparator = getPathSeparator;
 exports.getPlatformInfo = getPlatformInfo;
 exports.isCaseSensitiveFs = isCaseSensitiveFs;
-exports.isLinux = isLinux;
-exports.isMac = isMac;
 exports.isWindows = isWindows;
 exports.normalizeLineEndings = normalizeLineEndings;
 exports.pathsEqual = pathsEqual;
-//# sourceMappingURL=index.cjs.js.map

package/core/platform/index.d.ts

@@ -1,3 +1,185 @@
-export * from './detect';
-export * from './line-endings';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Platform information.
+ */
+interface PlatformInfo {
+    /** Operating system */
+    os: 'darwin' | 'linux' | 'win32' | 'freebsd' | 'sunos' | 'aix' | 'other';
+    /** CPU architecture */
+    arch: string;
+    /** Node.js version */
+    nodeVersion: string;
+    /** Is Windows */
+    isWindows: boolean;
+    /** Is macOS */
+    isMac: boolean;
+    /** Is Linux */
+    isLinux: boolean;
+    /** File system case sensitivity */
+    caseSensitive: boolean;
+    /** Path separator for platform */
+    pathSeparator: '/' | '\\';
+    /** Line ending for platform */
+    lineEnding: '\n' | '\r\n';
+}
+/**
+ * Detect if file system is case sensitive.
+ *
+ * @returns True if file system is case-sensitive
+ *
+ * @example Detecting case sensitivity
+ * ```typescript
+ * if (detectCaseSensitivity()) {
+ *   // Linux: 'File.ts' and 'file.ts' are different files
+ * } else {
+ *   // Windows/macOS: treat as same file
+ * }
+ * ```
+ */
+declare function detectCaseSensitivity(): boolean;
+/**
+ * Check if file system is case-sensitive.
+ *
+ * @returns True if file system is case-sensitive
+ *
+ * @example Checking case sensitivity
+ * ```typescript
+ * const caseSensitive = isCaseSensitiveFs()
+ * // => true on Linux, false on Windows/macOS
+ * ```
+ */
+declare function isCaseSensitiveFs(): boolean;
+/**
+ * Get comprehensive platform information.
+ *
+ * @returns Platform information object (cached after first call)
+ *
+ * @example Getting platform information
+ * ```typescript
+ * const info = getPlatformInfo()
+ * console.log(info.os)           // => 'linux'
+ * console.log(info.pathSeparator) // => '/'
+ * console.log(info.lineEnding)    // => '\n'
+ * ```
+ */
+declare function getPlatformInfo(): PlatformInfo;
+/**
+ * Detect current platform.
+ *
+ * @returns Platform information object
+ *
+ * @example Detecting current platform
+ * ```typescript
+ * const platform = detectPlatform()
+ * if (platform.isWindows) {
+ *   // Windows-specific handling
+ * }
+ * ```
+ */
+declare function detectPlatform(): PlatformInfo;
+/**
+ * Check if running on Windows.
+ *
+ * @returns True if running on Windows
+ *
+ * @example Checking for Windows
+ * ```typescript
+ * if (isWindows()) {
+ *   // Use Windows-specific paths or commands
+ * }
+ * ```
+ */
+declare function isWindows(): boolean;
+
+/** Unix line ending */
+declare const LF = "\n";
+/** Windows line ending */
+declare const CRLF = "\r\n";
+/**
+ * Target specification for normalizing line endings.
+ */
+type LineEndingStyle = 'lf' | 'crlf' | 'auto';
+/**
+ * Result of analyzing line endings in content.
+ */
+type DetectedLineEnding = 'lf' | 'crlf' | 'mixed' | 'none';
+/**
+ * Get platform-appropriate line ending.
+ *
+ * @returns Line ending for current platform
+ *
+ * @example Getting platform line ending
+ * ```typescript
+ * const eol = getLineEnding()
+ * const lines = ['line1', 'line2', 'line3']
+ * const content = lines.join(eol)
+ * ```
+ */
+declare function getLineEnding(): '\n' | '\r\n';
+/**
+ * Get platform-appropriate path separator.
+ *
+ * @returns Path separator for current platform
+ *
+ * @example Getting platform path separator
+ * ```typescript
+ * const sep = getPathSeparator()
+ * const fullPath = ['src', 'utils', 'helpers.ts'].join(sep)
+ * ```
+ */
+declare function getPathSeparator(): '/' | '\\';
+/**
+ * Normalize line endings in content.
+ *
+ * @param content - Content to normalize
+ * @param style - Target line ending style ('lf', 'crlf', or 'auto' for platform default)
+ * @returns Content with normalized line endings
+ *
+ * @example Normalizing line endings
+ * ```typescript
+ * // Normalize to Unix line endings
+ * const normalized = normalizeLineEndings('line1\r\nline2\r\n', 'lf')
+ * // => 'line1\nline2\n'
+ *
+ * // Use platform default
+ * const platformNormalized = normalizeLineEndings(content, 'auto')
+ * ```
+ */
+declare function normalizeLineEndings(content: string, style?: LineEndingStyle): string;
+/**
+ * Detect line ending style used in content.
+ *
+ * @param content - Content to analyze
+ * @returns Detected line ending style
+ *
+ * @example Detecting line ending style
+ * ```typescript
+ * const ending = detectLineEnding('line1\nline2\n')
+ * // => 'lf'
+ *
+ * const mixed = detectLineEnding('line1\r\nline2\nline3')
+ * // => 'mixed'
+ * ```
+ */
+declare function detectLineEnding(content: string): DetectedLineEnding;
+/**
+ * Compare paths with case sensitivity awareness.
+ *
+ * @param path1 - First path
+ * @param path2 - Second path
+ * @returns True if paths are equal (respecting case sensitivity)
+ *
+ * @example Comparing paths
+ * ```typescript
+ * // On case-insensitive filesystem (Windows/macOS)
+ * pathsEqual('src/App.tsx', 'src/app.tsx')
+ * // => true
+ *
+ * // On case-sensitive filesystem (Linux)
+ * pathsEqual('src/App.tsx', 'src/app.tsx')
+ * // => false
+ * ```
+ */
+declare function pathsEqual(path1: string, path2: string): boolean;
+
+export { CRLF, LF, detectCaseSensitivity, detectLineEnding, detectPlatform, getLineEnding, getPathSeparator, getPlatformInfo, isCaseSensitiveFs, isWindows, normalizeLineEndings, pathsEqual };
+export type { DetectedLineEnding, LineEndingStyle, PlatformInfo };

package/core/platform/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/project-scope/src/core/platform/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/project-scope/src/core/platform/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAC5C,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC/G,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,EAAE,EAAE,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA"}