@hyperfrontend/builder 0.1.0

package/_dependencies/@hyperfrontend/project-scope/index.cjs.js

@@ -0,0 +1,222 @@
+'use strict';
+const index_cjs_js$4 = require('../immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$3 = require('../immutable-api-utils/built-in-copy/console/index.cjs.js');
+const index_cjs_js$5 = require('../immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$2 = require('../immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js = require('../immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$1 = require('../logging/index.cjs.js');
+const index_cjs_js$7 = require('../immutable-api-utils/built-in-copy/map/index.cjs.js');
+
+const loggerRegistry = index_cjs_js.createSet();
+let globalLogLevel = null;
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (index_cjs_js$4.isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of index_cjs_js$2.entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && index_cjs_js$2.keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${index_cjs_js$5.stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = index_cjs_js$1.createLogger(createLogFn(index_cjs_js$3.error), createLogFn(index_cjs_js$3.warn), createLogFn(index_cjs_js$3.log), createLogFn(index_cjs_js$3.info), createLogFn(index_cjs_js$3.debug));
+    baseLogger.setLogLevel(globalLogLevel ?? level);
+    const scopedLogger = index_cjs_js$2.freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+const logger = createScopedLogger('project-scope');
+
+const fsLogger = createScopedLogger('project-scope:fs');
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+
+const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
+
+const fsWriteLogger = createScopedLogger('project-scope:fs:write');
+
+const packageLogger = createScopedLogger('project-scope:project:package');
+
+const depsLogger = createScopedLogger('project-scope:heuristics:deps');
+
+const cacheRegistry = index_cjs_js.createSet();
+function createCache(options) {
+    const { ttl, maxSize } = options ?? {};
+    const store = index_cjs_js$7.createMap();
+    const insertionOrder = [];
+    function isExpired(entry) {
+        if (ttl === undefined)
+            return false;
+        return Date.now() - entry.timestamp > ttl;
+    }
+    function evictIfNeeded() {
+        if (maxSize === undefined)
+            return;
+        while (store.size >= maxSize && insertionOrder.length > 0) {
+            const oldestKey = insertionOrder.shift();
+            if (oldestKey !== undefined) {
+                store.delete(oldestKey);
+            }
+        }
+    }
+    function removeFromOrder(key) {
+        const index = insertionOrder.indexOf(key);
+        if (index !== -1) {
+            insertionOrder.splice(index, 1);
+        }
+    }
+    const cache = {
+        get(key) {
+            const entry = store.get(key);
+            if (!entry)
+                return undefined;
+            if (isExpired(entry)) {
+                store.delete(key);
+                removeFromOrder(key);
+                return undefined;
+            }
+            return entry.value;
+        },
+        set(key, value) {
+            if (store.has(key)) {
+                removeFromOrder(key);
+            }
+            else {
+                evictIfNeeded();
+            }
+            store.set(key, { value, timestamp: Date.now() });
+            insertionOrder.push(key);
+        },
+        has(key) {
+            const entry = store.get(key);
+            if (!entry)
+                return false;
+            if (isExpired(entry)) {
+                store.delete(key);
+                removeFromOrder(key);
+                return false;
+            }
+            return true;
+        },
+        delete(key) {
+            removeFromOrder(key);
+            return store.delete(key);
+        },
+        clear() {
+            store.clear();
+            insertionOrder.length = 0;
+        },
+        size() {
+            return store.size;
+        },
+        keys() {
+            return [...insertionOrder];
+        },
+    };
+    cacheRegistry.add(cache);
+    return index_cjs_js$2.freeze(cache);
+}
+
+const walkLogger = createScopedLogger('project-scope:project:walk');
+
+const searchLogger = createScopedLogger('project-scope:project:search');
+
+const entryPointLogger = createScopedLogger('project-scope:heuristics:entry-points');
+const entryPointCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const techLogger = createScopedLogger('project-scope:tech');
+const detectAllCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const projectTypeLogger = createScopedLogger('project-scope:heuristics:project-type');
+
+const rootLogger = createScopedLogger('project-scope:root');
+
+const nxLogger = createScopedLogger('project-scope:nx');
+
+const nxConfigLogger = createScopedLogger('project-scope:nx:config');
+
+const configLogger = createScopedLogger('project-scope:config');
+const configDetectionCache = createCache({ ttl: 30000, maxSize: 50 });
+const analyzeLogger = createScopedLogger('project-scope:analyze');
+
+const cliLogger = createScopedLogger('project-scope:cli');
+const output = index_cjs_js$1.createLogger(index_cjs_js$3.error, undefined, index_cjs_js$3.log);
+output.setLogLevel('log');
+
+const encodingLogger = createScopedLogger('project-scope:encoding');
+
+const convertLogger = createScopedLogger('project-scope:encoding:convert');
+
+const frameworkLogger = createScopedLogger('project-scope:heuristics:framework');
+const frameworkIdCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const vfsLogger = createScopedLogger('project-scope:vfs');
+
+const diffLogger = createScopedLogger('project-scope:vfs:diff');
+
+const Mode = index_cjs_js$2.freeze({
+    Overwrite: 'overwrite',
+    ExclusiveCreate: 'exclusive',
+    SkipIfExists: 'skip',
+});
+
+const fsTreeLogger = createScopedLogger('project-scope:vfs:tree');
+
+const factoryLogger = createScopedLogger('project-scope:vfs:factory');
+exports.Mode = Mode;
+exports.createCache = createCache;
+exports.createScopedLogger = createScopedLogger;
+exports.logger = logger;
+exports.sanitize = sanitize;

package/_dependencies/@hyperfrontend/project-scope/index.esm.js

@@ -0,0 +1,219 @@
+
+import { isArray } from '../immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify } from '../immutable-api-utils/built-in-copy/json/index.esm.js';
+import { freeze, entries, keys } from '../immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createLogger } from '../logging/index.esm.js';
+import { createMap } from '../immutable-api-utils/built-in-copy/map/index.esm.js';
+
+const loggerRegistry = createSet();
+let globalLogLevel = null;
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
+    baseLogger.setLogLevel(globalLogLevel ?? level);
+    const scopedLogger = freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+const logger = createScopedLogger('project-scope');
+
+const fsLogger = createScopedLogger('project-scope:fs');
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+
+const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
+
+const fsWriteLogger = createScopedLogger('project-scope:fs:write');
+
+const packageLogger = createScopedLogger('project-scope:project:package');
+
+const depsLogger = createScopedLogger('project-scope:heuristics:deps');
+
+const cacheRegistry = createSet();
+function createCache(options) {
+    const { ttl, maxSize } = options ?? {};
+    const store = createMap();
+    const insertionOrder = [];
+    function isExpired(entry) {
+        if (ttl === undefined)
+            return false;
+        return Date.now() - entry.timestamp > ttl;
+    }
+    function evictIfNeeded() {
+        if (maxSize === undefined)
+            return;
+        while (store.size >= maxSize && insertionOrder.length > 0) {
+            const oldestKey = insertionOrder.shift();
+            if (oldestKey !== undefined) {
+                store.delete(oldestKey);
+            }
+        }
+    }
+    function removeFromOrder(key) {
+        const index = insertionOrder.indexOf(key);
+        if (index !== -1) {
+            insertionOrder.splice(index, 1);
+        }
+    }
+    const cache = {
+        get(key) {
+            const entry = store.get(key);
+            if (!entry)
+                return undefined;
+            if (isExpired(entry)) {
+                store.delete(key);
+                removeFromOrder(key);
+                return undefined;
+            }
+            return entry.value;
+        },
+        set(key, value) {
+            if (store.has(key)) {
+                removeFromOrder(key);
+            }
+            else {
+                evictIfNeeded();
+            }
+            store.set(key, { value, timestamp: Date.now() });
+            insertionOrder.push(key);
+        },
+        has(key) {
+            const entry = store.get(key);
+            if (!entry)
+                return false;
+            if (isExpired(entry)) {
+                store.delete(key);
+                removeFromOrder(key);
+                return false;
+            }
+            return true;
+        },
+        delete(key) {
+            removeFromOrder(key);
+            return store.delete(key);
+        },
+        clear() {
+            store.clear();
+            insertionOrder.length = 0;
+        },
+        size() {
+            return store.size;
+        },
+        keys() {
+            return [...insertionOrder];
+        },
+    };
+    cacheRegistry.add(cache);
+    return freeze(cache);
+}
+
+const walkLogger = createScopedLogger('project-scope:project:walk');
+
+const searchLogger = createScopedLogger('project-scope:project:search');
+
+const entryPointLogger = createScopedLogger('project-scope:heuristics:entry-points');
+const entryPointCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const techLogger = createScopedLogger('project-scope:tech');
+const detectAllCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const projectTypeLogger = createScopedLogger('project-scope:heuristics:project-type');
+
+const rootLogger = createScopedLogger('project-scope:root');
+
+const nxLogger = createScopedLogger('project-scope:nx');
+
+const nxConfigLogger = createScopedLogger('project-scope:nx:config');
+
+const configLogger = createScopedLogger('project-scope:config');
+const configDetectionCache = createCache({ ttl: 30000, maxSize: 50 });
+const analyzeLogger = createScopedLogger('project-scope:analyze');
+
+const cliLogger = createScopedLogger('project-scope:cli');
+const output = createLogger(error, undefined, log);
+output.setLogLevel('log');
+
+const encodingLogger = createScopedLogger('project-scope:encoding');
+
+const convertLogger = createScopedLogger('project-scope:encoding:convert');
+
+const frameworkLogger = createScopedLogger('project-scope:heuristics:framework');
+const frameworkIdCache = createCache({ ttl: 60000, maxSize: 50 });
+
+const vfsLogger = createScopedLogger('project-scope:vfs');
+
+const diffLogger = createScopedLogger('project-scope:vfs:diff');
+
+const Mode = freeze({
+    Overwrite: 'overwrite',
+    ExclusiveCreate: 'exclusive',
+    SkipIfExists: 'skip',
+});
+
+const fsTreeLogger = createScopedLogger('project-scope:vfs:tree');
+
+const factoryLogger = createScopedLogger('project-scope:vfs:factory');
+
+export { Mode, createCache, createScopedLogger, logger, sanitize };

package/_dependencies/@hyperfrontend/project-scope/models/index.cjs.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/_dependencies/@hyperfrontend/project-scope/models/index.esm.js

@@ -0,0 +1 @@
+

package/_dependencies/@hyperfrontend/project-scope/nx/index.cjs.js

@@ -0,0 +1,94 @@
+'use strict';
+const index_cjs_js$4 = require('../../immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$3 = require('../../immutable-api-utils/built-in-copy/console/index.cjs.js');
+const index_cjs_js$5 = require('../../immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$2 = require('../../immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js = require('../../immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$1 = require('../../logging/index.cjs.js');
+
+const loggerRegistry = index_cjs_js.createSet();
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (index_cjs_js$4.isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of index_cjs_js$2.entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && index_cjs_js$2.keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${index_cjs_js$5.stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = index_cjs_js$1.createLogger(createLogFn(index_cjs_js$3.error), createLogFn(index_cjs_js$3.warn), createLogFn(index_cjs_js$3.log), createLogFn(index_cjs_js$3.info), createLogFn(index_cjs_js$3.debug));
+    baseLogger.setLogLevel(level);
+    const scopedLogger = index_cjs_js$2.freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+createScopedLogger('project-scope');
+
+createScopedLogger('project-scope:fs');
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+
+const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
+
+createScopedLogger('project-scope:fs:write');
+
+const packageLogger = createScopedLogger('project-scope:project:package');
+
+createScopedLogger('project-scope:root');
+
+const nxLogger = createScopedLogger('project-scope:nx');
+
+const nxConfigLogger = createScopedLogger('project-scope:nx:config');

package/_dependencies/@hyperfrontend/project-scope/nx/index.esm.js

@@ -0,0 +1,94 @@
+
+import { isArray } from '../../immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../../immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify } from '../../immutable-api-utils/built-in-copy/json/index.esm.js';
+import { freeze, entries, keys } from '../../immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createLogger } from '../../logging/index.esm.js';
+
+const loggerRegistry = createSet();
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
+    baseLogger.setLogLevel(level);
+    const scopedLogger = freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+createScopedLogger('project-scope');
+
+createScopedLogger('project-scope:fs');
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+
+const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
+
+createScopedLogger('project-scope:fs:write');
+
+const packageLogger = createScopedLogger('project-scope:project:package');
+
+createScopedLogger('project-scope:root');
+
+const nxLogger = createScopedLogger('project-scope:nx');
+
+const nxConfigLogger = createScopedLogger('project-scope:nx:config');