@hyperfrontend/project-scope 0.2.1 → 0.2.2

package/_shared/core/path/resolve/index.cjs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const { exists } = require('../../fs/stat/index.cjs.js');
+const { normalizePath } = require('../normalize/index.cjs.js');
+const node_path = require('node:path');
+const node_fs = require('node:fs');
+
+function resolvePath(...segments) {
+    return normalizePath(node_path.resolve(...segments));
+}
+function resolveFromWorkspace(workspaceRoot, ...segments) {
+    return normalizePath(node_path.resolve(workspaceRoot, ...segments));
+}
+function resolveRealPath(filePath) {
+    if (!exists(filePath)) {
+        return null;
+    }
+    try {
+        return normalizePath(node_fs.realpathSync(filePath));
+    }
+    catch {
+        return null;
+    }
+}
+function relativePath(from, to) {
+    return normalizePath(node_path.relative(from, to));
+}
+function joinPath(...segments) {
+    return normalizePath(node_path.join(...segments));
+}
+function isAbsolute(filePath) {
+    return node_path.isAbsolute(filePath);
+}
+function offsetFromRoot(filePath) {
+    const segments = normalizePath(filePath).split('/').filter(Boolean);
+    if (segments.length === 0)
+        return '';
+    return segments.map(() => '..').join('/') + '/';
+}
+
+exports.resolvePath = resolvePath;
+exports.resolveFromWorkspace = resolveFromWorkspace;
+exports.resolveRealPath = resolveRealPath;
+exports.relativePath = relativePath;
+exports.joinPath = joinPath;
+exports.isAbsolute = isAbsolute;
+exports.offsetFromRoot = offsetFromRoot;

package/_shared/core/path/resolve/index.esm.js

@@ -0,0 +1,41 @@
+import { exists } from '../../fs/stat/index.esm.js';
+import { join as join$1 } from '../join/index.esm.js';
+import { normalizePath } from '../normalize/index.esm.js';
+import { from } from '../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { realpathSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+
+function resolvePath(...segments) {
+    return normalizePath(resolve(...segments));
+}
+function resolveFromWorkspace(workspaceRoot, ...segments) {
+    return normalizePath(resolve(workspaceRoot, ...segments));
+}
+function resolveRealPath(filePath) {
+    if (!exists(filePath)) {
+        return null;
+    }
+    try {
+        return normalizePath(realpathSync(filePath));
+    }
+    catch {
+        return null;
+    }
+}
+function relativePath(from, to) {
+    return normalizePath(relative(from, to));
+}
+function joinPath(...segments) {
+    return normalizePath(join$1(...segments));
+}
+function isAbsolute(filePath) {
+    return isAbsolute$1(filePath);
+}
+function offsetFromRoot(filePath) {
+    const segments = normalizePath(filePath).split('/').filter(Boolean);
+    if (segments.length === 0)
+        return '';
+    return segments.map(() => '..').join('/') + '/';
+}
+
+export { resolvePath, resolveFromWorkspace, resolveRealPath, relativePath, joinPath, isAbsolute, offsetFromRoot };

package/_shared/core/path/segments/index.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { normalizePath } = require('../normalize/index.cjs.js');
+const node_path = require('node:path');
+
+function pathSegments(filePath) {
+    return filePath.split(/[/\\]/).filter((segment) => segment.length > 0);
+}
+function getBasename(filePath, ext) {
+    return node_path.basename(filePath, ext);
+}
+function getDirname(filePath) {
+    return normalizePath(node_path.dirname(filePath));
+}
+function getExtension(filePath) {
+    return node_path.extname(filePath);
+}
+function getFileNameWithoutExtension(filePath) {
+    const parsed = node_path.parse(filePath);
+    return parsed.name;
+}
+function parsePath(filePath) {
+    const parsed = node_path.parse(filePath);
+    return {
+        root: parsed.root,
+        dir: normalizePath(parsed.dir),
+        base: parsed.base,
+        ext: parsed.ext,
+        name: parsed.name,
+    };
+}
+
+exports.pathSegments = pathSegments;
+exports.getBasename = getBasename;
+exports.getDirname = getDirname;
+exports.getExtension = getExtension;
+exports.getFileNameWithoutExtension = getFileNameWithoutExtension;
+exports.parsePath = parsePath;

package/_shared/core/path/segments/index.esm.js

@@ -0,0 +1,31 @@
+import { normalizePath } from '../normalize/index.esm.js';
+import { basename, dirname, extname, parse as parse$1 } from 'node:path';
+
+function pathSegments(filePath) {
+    return filePath.split(/[/\\]/).filter((segment) => segment.length > 0);
+}
+function getBasename(filePath, ext) {
+    return basename(filePath, ext);
+}
+function getDirname(filePath) {
+    return normalizePath(dirname(filePath));
+}
+function getExtension(filePath) {
+    return extname(filePath);
+}
+function getFileNameWithoutExtension(filePath) {
+    const parsed = parse$1(filePath);
+    return parsed.name;
+}
+function parsePath(filePath) {
+    const parsed = parse$1(filePath);
+    return {
+        root: parsed.root,
+        dir: normalizePath(parsed.dir),
+        base: parsed.base,
+        ext: parsed.ext,
+        name: parsed.name,
+    };
+}
+
+export { pathSegments, getBasename, getDirname, getExtension, getFileNameWithoutExtension, parsePath };

package/_shared/core/patterns/glob/index.cjs.js

@@ -0,0 +1,145 @@
+'use strict';
+
+function matchGlobPattern(path, pattern) {
+    return matchSegments(path.split('/'), pattern.split('/'), 0, 0);
+}
+function matchSegments(pathParts, patternParts, pathIdx, patternIdx) {
+    if (pathIdx === pathParts.length && patternIdx === patternParts.length) {
+        return true;
+    }
+    if (patternIdx >= patternParts.length) {
+        return false;
+    }
+    const patternPart = patternParts[patternIdx];
+    if (patternPart === '**') {
+        for (let i = pathIdx; i <= pathParts.length; i++) {
+            if (matchSegments(pathParts, patternParts, i, patternIdx + 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (pathIdx >= pathParts.length) {
+        return false;
+    }
+    const pathPart = pathParts[pathIdx];
+    if (matchSegment(pathPart, patternPart)) {
+        return matchSegments(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
+    }
+    return false;
+}
+function matchSegment(text, pattern) {
+    let textIdx = 0;
+    let patternIdx = 0;
+    while (patternIdx < pattern.length) {
+        const char = pattern[patternIdx];
+        if (char === '*') {
+            patternIdx++;
+            if (patternIdx === pattern.length) {
+                return true;
+            }
+            for (let i = textIdx; i <= text.length; i++) {
+                if (matchSegmentFrom(text, i, pattern, patternIdx)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else if (char === '?') {
+            if (textIdx >= text.length) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+        else if (char === '{') {
+            const closeIdx = findClosingBrace(pattern, patternIdx);
+            if (closeIdx === -1) {
+                if (textIdx >= text.length || text[textIdx] !== char) {
+                    return false;
+                }
+                textIdx++;
+                patternIdx++;
+            }
+            else {
+                const alternatives = extractAlternatives(pattern.slice(patternIdx + 1, closeIdx));
+                for (const alt of alternatives) {
+                    if (matchSegmentFrom(text, textIdx, text.slice(0, textIdx) + alt + pattern.slice(closeIdx + 1), textIdx)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        else {
+            if (textIdx >= text.length || text[textIdx] !== char) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+    }
+    return textIdx === text.length;
+}
+function matchSegmentFrom(text, textIdx, pattern, patternIdx) {
+    const remainingText = text.slice(textIdx);
+    const remainingPattern = pattern.slice(patternIdx);
+    return matchSegment(remainingText, remainingPattern);
+}
+function findClosingBrace(pattern, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < pattern.length; i++) {
+        if (pattern[i] === '{') {
+            depth++;
+        }
+        else if (pattern[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function extractAlternatives(content) {
+    const alternatives = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        if (char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            alternatives.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        alternatives.push(current);
+    }
+    return alternatives;
+}
+function matchesAnyPattern(path, patterns) {
+    return patterns.some((pattern) => matchGlobPattern(path, pattern));
+}
+function matchesExact(path, pattern) {
+    return path === pattern;
+}
+
+exports.matchGlobPattern = matchGlobPattern;
+exports.matchSegments = matchSegments;
+exports.matchSegment = matchSegment;
+exports.matchSegmentFrom = matchSegmentFrom;
+exports.findClosingBrace = findClosingBrace;
+exports.extractAlternatives = extractAlternatives;
+exports.matchesAnyPattern = matchesAnyPattern;
+exports.matchesExact = matchesExact;

package/_shared/core/patterns/glob/index.esm.js

@@ -0,0 +1,136 @@
+function matchGlobPattern(path, pattern) {
+    return matchSegments(path.split('/'), pattern.split('/'), 0, 0);
+}
+function matchSegments(pathParts, patternParts, pathIdx, patternIdx) {
+    if (pathIdx === pathParts.length && patternIdx === patternParts.length) {
+        return true;
+    }
+    if (patternIdx >= patternParts.length) {
+        return false;
+    }
+    const patternPart = patternParts[patternIdx];
+    if (patternPart === '**') {
+        for (let i = pathIdx; i <= pathParts.length; i++) {
+            if (matchSegments(pathParts, patternParts, i, patternIdx + 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (pathIdx >= pathParts.length) {
+        return false;
+    }
+    const pathPart = pathParts[pathIdx];
+    if (matchSegment(pathPart, patternPart)) {
+        return matchSegments(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
+    }
+    return false;
+}
+function matchSegment(text, pattern) {
+    let textIdx = 0;
+    let patternIdx = 0;
+    while (patternIdx < pattern.length) {
+        const char = pattern[patternIdx];
+        if (char === '*') {
+            patternIdx++;
+            if (patternIdx === pattern.length) {
+                return true;
+            }
+            for (let i = textIdx; i <= text.length; i++) {
+                if (matchSegmentFrom(text, i, pattern, patternIdx)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else if (char === '?') {
+            if (textIdx >= text.length) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+        else if (char === '{') {
+            const closeIdx = findClosingBrace(pattern, patternIdx);
+            if (closeIdx === -1) {
+                if (textIdx >= text.length || text[textIdx] !== char) {
+                    return false;
+                }
+                textIdx++;
+                patternIdx++;
+            }
+            else {
+                const alternatives = extractAlternatives(pattern.slice(patternIdx + 1, closeIdx));
+                for (const alt of alternatives) {
+                    if (matchSegmentFrom(text, textIdx, text.slice(0, textIdx) + alt + pattern.slice(closeIdx + 1), textIdx)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        else {
+            if (textIdx >= text.length || text[textIdx] !== char) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+    }
+    return textIdx === text.length;
+}
+function matchSegmentFrom(text, textIdx, pattern, patternIdx) {
+    const remainingText = text.slice(textIdx);
+    const remainingPattern = pattern.slice(patternIdx);
+    return matchSegment(remainingText, remainingPattern);
+}
+function findClosingBrace(pattern, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < pattern.length; i++) {
+        if (pattern[i] === '{') {
+            depth++;
+        }
+        else if (pattern[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function extractAlternatives(content) {
+    const alternatives = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        if (char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            alternatives.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        alternatives.push(current);
+    }
+    return alternatives;
+}
+function matchesAnyPattern(path, patterns) {
+    return patterns.some((pattern) => matchGlobPattern(path, pattern));
+}
+function matchesExact(path, pattern) {
+    return path === pattern;
+}
+
+export { matchGlobPattern, matchSegments, matchSegment, matchSegmentFrom, findClosingBrace, extractAlternatives, matchesAnyPattern, matchesExact };

package/_shared/core/platform/detect/index.cjs.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const node_os = require('node:os');
+
+let cachedPlatformInfo = null;
+let cachedCaseSensitive = null;
+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;
+}
+function isCaseSensitiveFs() {
+    return detectCaseSensitivity();
+}
+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;
+}
+function detectPlatform() {
+    return getPlatformInfo();
+}
+function isWindows() {
+    return process.platform === 'win32';
+}
+
+exports.cachedPlatformInfo = cachedPlatformInfo;
+exports.cachedCaseSensitive = cachedCaseSensitive;
+exports.detectCaseSensitivity = detectCaseSensitivity;
+exports.isCaseSensitiveFs = isCaseSensitiveFs;
+exports.getPlatformInfo = getPlatformInfo;
+exports.detectPlatform = detectPlatform;
+exports.isWindows = isWindows;

package/_shared/core/platform/detect/index.esm.js

@@ -0,0 +1,95 @@
+import { join as join$1 } from '../../path/join/index.esm.js';
+import { mkdtempSync, writeFileSync, existsSync, unlinkSync, rmdirSync } from 'node:fs';
+import { tmpdir, platform, arch } from 'node:os';
+
+let cachedPlatformInfo = null;
+let cachedCaseSensitive = null;
+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 = mkdtempSync(join$1(tmpdir(), 'case-sensitivity-test-'));
+        const testFile = join$1(secureTestDir, 'A');
+        const testFileLower = join$1(secureTestDir, 'a');
+        writeFileSync(testFile, '');
+        cachedCaseSensitive = !existsSync(testFileLower);
+        unlinkSync(testFile);
+    }
+    catch {
+        cachedCaseSensitive = true;
+    }
+    finally {
+        if (secureTestDir) {
+            try {
+                rmdirSync(secureTestDir);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    return cachedCaseSensitive;
+}
+function isCaseSensitiveFs() {
+    return detectCaseSensitivity();
+}
+function getPlatformInfo() {
+    if (cachedPlatformInfo) {
+        return cachedPlatformInfo;
+    }
+    const os = platform();
+    const archInfo = 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;
+}
+function detectPlatform() {
+    return getPlatformInfo();
+}
+function isWindows() {
+    return process.platform === 'win32';
+}
+
+export { cachedPlatformInfo, cachedCaseSensitive, detectCaseSensitivity, isCaseSensitiveFs, getPlatformInfo, detectPlatform, isWindows };

package/_shared/core/platform/line-endings/index.cjs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { isWindows, detectCaseSensitivity } = require('../detect/index.cjs.js');
+
+const LF = '\n';
+const CRLF = '\r\n';
+function getLineEnding() {
+    return isWindows() ? CRLF : LF;
+}
+function getPathSeparator() {
+    return isWindows() ? '\\' : '/';
+}
+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);
+}
+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';
+}
+function pathsEqual(path1, path2) {
+    const caseSensitive = detectCaseSensitivity();
+    if (caseSensitive) {
+        return path1 === path2;
+    }
+    return path1.toLowerCase() === path2.toLowerCase();
+}
+
+exports.LF = LF;
+exports.CRLF = CRLF;
+exports.getLineEnding = getLineEnding;
+exports.getPathSeparator = getPathSeparator;
+exports.normalizeLineEndings = normalizeLineEndings;
+exports.detectLineEnding = detectLineEnding;
+exports.pathsEqual = pathsEqual;