@decohere/core 0.0.1-dev.125 → 0.0.1-dev.5

package/commonjs/src/system/type.utils.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/es6/src/caching/cache-manager.js

@@ -1,82 +0,0 @@
-import { MapCache } from "./map-cache.js";
-export const Caches = {
-    default: "DEFAULT",
-    memoize: "MEMOIZE_CACHE"
-};
-/**
- * Central cache manager for managing named cache instances
- */ class CacheManager {
-    caches = new Map();
-    defaultCacheName = Caches.default;
-    /**
-	 * Set a cache instance with the given name
-	 * @param name - The name of the cache
-	 * @param cache - The cache instance
-	 */ setCache(name, cache) {
-        this.caches.set(name, cache);
-    }
-    /**
-	 * Get a cache instance by name
-	 * @param name - The name of the cache, defaults to "DEFAULT"
-	 * @returns The cache instance
-	 */ getCache(name, memoize = false) {
-        const cacheName = name ?? this.defaultCacheName;
-        if (!this.caches.has(cacheName)) {
-            const cache = new MapCache({
-                memoize
-            });
-            this.caches.set(cacheName, cache);
-        }
-        return this.caches.get(cacheName);
-    }
-    /**
-	 * Clear a cache by name. If no name is provided, clears the default cache.
-	 * Note: This only works if the cache implements a clear() method.
-	 * @param name - The name of the cache to clear
-	 */ flush(name) {
-        const cacheName = name ?? this.defaultCacheName;
-        const cache = this.caches.get(cacheName);
-        cache.flushAll();
-    }
-    flushAllCaches() {
-        for (const [, cache] of this.caches){
-            cache.flushAll();
-        }
-    }
-    /**
-	 * Remove a cache instance by name
-	 * @param name - The name of the cache to remove
-	 */ removeCache(name) {
-        this.caches.delete(name);
-    }
-    /**
-	 * Check if a cache with the given name exists
-	 * @param name - The name of the cache
-	 * @returns True if the cache exists, false otherwise
-	 */ hasCache(name) {
-        return this.caches.has(name);
-    }
-    instanceIds = new WeakMap();
-    instanceIdCounter = 0;
-    /**
-	 * Generate a cache key for a given instance, function name, and arguments.
-	 * Each instance receives a stable numeric ID so cache entries are never
-	 * shared across instances of the same class.
-	 * @param instance - The class instance (`this` at call time)
-	 * @param functionName - The name of the decorated method
-	 * @param args - The method arguments
-	 * @returns A unique cache key string
-	 */ generateCacheKey(instance, functionName, args) {
-        if (!this.instanceIds.has(instance)) {
-            this.instanceIds.set(instance, ++this.instanceIdCounter);
-        }
-        const instanceId = this.instanceIds.get(instance);
-        const argsStr = JSON.stringify({
-            args
-        }, (_key, val)=>typeof val === "function" ? `[Function:${val.name}]` : val);
-        return `${instance.constructor.name}#${instanceId}|${functionName}|${argsStr}`;
-    }
-}
-/**
- * Singleton instance of the cache manager
- */ export const Caching = new CacheManager();

package/es6/src/caching/cache.decorator.js

@@ -1,51 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import { isPromise } from "node:util/types";
-import { FunctionDecorator, ignoreIf } from "../system/decorator.js";
-import { Caching } from "./cache-manager.js";
-export class CacheDecorator extends FunctionDecorator {
-    decorator(_target, propertyKey, descriptor) {
-        const cacheInstance = this.options?.cache ?? Caching.getCache(this.options?.name);
-        const keyFn = this.options?.keyFn;
-        const originalMethod = descriptor.value;
-        const wrapped = function(...args) {
-            const cacheKey = keyFn ? keyFn(...args) : Caching.generateCacheKey(this, propertyKey, args);
-            if (cacheInstance.has(cacheKey)) {
-                const val = cacheInstance.get(cacheKey);
-                return val;
-            }
-            const resultOrPromise = originalMethod.apply(this, args);
-            if (isPromise(resultOrPromise)) {
-                resultOrPromise.then((result)=>{
-                    cacheInstance.set(cacheKey, result);
-                }, ()=>{
-                /* rejection propagates via the returned promise */ });
-            } else {
-                cacheInstance.set(cacheKey, resultOrPromise);
-            }
-            return resultOrPromise;
-        };
-        Object.defineProperty(wrapped, "name", {
-            value: propertyKey
-        });
-        descriptor.value = wrapped;
-    }
-}
-_ts_decorate([
-    ignoreIf("FORGE_DISABLE_CACHE"),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        String,
-        typeof PropertyDescriptor === "undefined" ? Object : PropertyDescriptor
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], CacheDecorator.prototype, "decorator", null);
-export const cache = new CacheDecorator().decoratorFactory;

package/es6/src/caching/cache.js

@@ -1,3 +0,0 @@
-/**
- * Interface for cache implementations used by the @cache() decorator
- */ export { };

package/es6/src/caching/invalidate-cache.decorator.js

@@ -1,71 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import { isPromise } from "node:util/types";
-import { FunctionDecorator, ignoreIf } from "../system/decorator.js";
-import { Caches, Caching } from "./cache-manager.js";
-export class InvalidateCacheDecorator extends FunctionDecorator {
-    decorator(_target, _propertyKey, descriptor) {
-        const { getKey, cache, name } = this.options;
-        const cacheInstance = cache ?? Caching.getCache(name);
-        const originalMethod = descriptor.value;
-        descriptor.value = function(...args) {
-            const resultOrPromise = originalMethod.apply(this, args);
-            const evict = ()=>{
-                const key = getKey(this, args);
-                cacheInstance.del(key);
-            };
-            if (isPromise(resultOrPromise)) {
-                resultOrPromise.then(evict);
-            } else {
-                evict();
-            }
-            return resultOrPromise;
-        };
-    }
-}
-_ts_decorate([
-    ignoreIf("FORGE_DISABLE_CACHE"),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        String,
-        typeof PropertyDescriptor === "undefined" ? Object : PropertyDescriptor
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], InvalidateCacheDecorator.prototype, "decorator", null);
-const buildGetKey = (method, keyFn)=>{
-    if (typeof method === "string") return ()=>method;
-    if (keyFn) return (_instance, args)=>keyFn(...args);
-    return (instance, args)=>Caching.generateCacheKey(instance, method.name, args);
-};
-export const invalidateCache = (method, options)=>{
-    const cache = options?.cache ?? Caching.getCache(options?.name);
-    return new InvalidateCacheDecorator().decoratorFactory({
-        getKey: buildGetKey(method, options?.keyFn),
-        ...options,
-        cache
-    });
-};
-invalidateCache.evict = (instance, method, args = [])=>{
-    const key = Caching.generateCacheKey(instance, method.name, args);
-    Caching.getCache().del(key);
-};
-export const invalidateMemoize = (method, options)=>{
-    const cache = options?.cache ?? Caching.getCache(options?.name ?? Caches.memoize, true);
-    return new InvalidateCacheDecorator().decoratorFactory({
-        getKey: buildGetKey(method),
-        ...options,
-        cache
-    });
-};
-invalidateMemoize.evict = (instance, method, args = [])=>{
-    const key = Caching.generateCacheKey(instance, method.name, args);
-    Caching.getCache(Caches.memoize, true).del(key);
-};

package/es6/src/caching/map-cache.js

@@ -1,35 +0,0 @@
-/**
- * The built-in cache: a plain `Map`, no expiry.
- *
- * By default `get` returns a `structuredClone` of an object, so a caller that changes what it
- * got back can't change the cached value. With `memoize` it returns the stored reference.
- * Scalars, `null` and `undefined` are returned as they are.
- */ export class MapCache {
-    #entries = new Map();
-    #memoize;
-    constructor(options = {}){
-        this.#memoize = options.memoize ?? false;
-    }
-    get isMemoize() {
-        return this.#memoize;
-    }
-    get(key) {
-        const value = this.#entries.get(key);
-        if (this.#memoize || value === null || typeof value !== "object") {
-            return value;
-        }
-        return structuredClone(value);
-    }
-    set(key, value) {
-        this.#entries.set(key, value);
-    }
-    has(key) {
-        return this.#entries.has(key);
-    }
-    del(key) {
-        this.#entries.delete(key);
-    }
-    flushAll() {
-        this.#entries.clear();
-    }
-}

package/es6/src/caching/memoize.decorator.js

@@ -1,27 +0,0 @@
-import { CacheDecorator } from "./cache.decorator.js";
-import { Caches, Caching } from "./cache-manager.js";
-/**
- * Memoize decorator class that extends CacheDecorator with memoization support
- * Automatically uses a memoization-capable cache (a MapCache that hands out references)
- */ export class MemoizeDecorator extends CacheDecorator {
-    decorator(target, propertyKey, descriptor) {
-        const cache = this.options?.cache ?? Caching.getCache(this.options?.name ?? Caches.memoize, true);
-        if (!cache.isMemoize) {
-            throw new Error("Memoize decorator requires a cache that supports memoization (stores references, not clones)");
-        }
-        // Pass the resolved cache to the base class by updating options
-        // This ensures the base class uses CacheNames.memoize when no cache was provided
-        this.options = {
-            ...this.options,
-            cache
-        };
-        return super.decorator(target, propertyKey, descriptor);
-    }
-}
-/**
- * Memoize decorator factory
- * Provides true memoization by storing object references instead of clones
- *
- * @param options - Optional configuration for the memoize decorator
- * @returns Decorator function
- */ export const memoize = new MemoizeDecorator().decoratorFactory;

package/es6/src/collections/find-duplicates.js

@@ -1,17 +0,0 @@
-export function findDuplicatesByKey(items, key) {
-    return findDuplicatesBy(items, (item)=>String(item[key]));
-}
-export function findDuplicatesBy(items, selector) {
-    const groups = new Map();
-    for (const item of items){
-        const k = selector(item);
-        const existing = groups.get(k) ?? [];
-        groups.set(k, [
-            ...existing,
-            item
-        ]);
-    }
-    return [
-        ...groups.entries()
-    ].filter(([, group])=>group.length > 1);
-}

package/es6/src/collections/merge-arrays.js

@@ -1,16 +0,0 @@
-export function mergeByKey(first, second, key) {
-    return mergeBy(first, second, (item)=>String(item[key]));
-}
-export function mergeBy(first, second, selector) {
-    // Second collection values win when keys collide.
-    const merged = [
-        ...first,
-        ...second
-    ];
-    return [
-        ...new Map(merged.map((item)=>[
-                selector(item),
-                item
-            ])).values()
-    ];
-}

package/es6/src/collections/sum.js

@@ -1,45 +0,0 @@
-export function sumByKey(objects, key) {
-    return sum(objects, key);
-}
-export function sumBy(objects, key) {
-    return sum(objects, key);
-}
-function extractValueFromItem(item, key) {
-    if (typeof key === "function") {
-        const result = key(item);
-        return isNumericValue(result) ? result : 0;
-    }
-    const value = item?.[key];
-    return isNumericValue(value) ? value : 0;
-}
-function isNumericValue(value) {
-    return typeof value === "number" || typeof value === "bigint";
-}
-function determineSumType(firstValue) {
-    return typeof firstValue === "bigint" ? "bigint" : "number";
-}
-function getInitialSumValue(sumType) {
-    return sumType === "bigint" ? 0n : 0;
-}
-function addValues(total, value, sumType) {
-    if (sumType === "bigint") {
-        const totalBigInt = total;
-        const valueBigInt = typeof value === "bigint" ? value : BigInt(value);
-        return totalBigInt + valueBigInt;
-    }
-    const totalNumber = total;
-    const valueNumber = typeof value === "number" ? value : Number(value);
-    return totalNumber + valueNumber;
-}
-function sum(objects, key) {
-    if (objects.length === 0) {
-        return 0;
-    }
-    const firstValue = extractValueFromItem(objects[0], key);
-    const sumType = determineSumType(firstValue);
-    const initialValue = getInitialSumValue(sumType);
-    return objects.reduce((total, item)=>{
-        const value = extractValueFromItem(item, key);
-        return addValues(total, value, sumType);
-    }, initialValue);
-}

package/es6/src/collections/unique-objects.js

@@ -1,21 +0,0 @@
-export function uniqueObjectsByKey(objects, key) {
-    return uniqueObjects(objects, key);
-}
-export function uniqueObjectsBy(objects, key) {
-    return uniqueObjects(objects, key);
-}
-function uniqueObjects(objects, key) {
-    const getKey = (key, item)=>{
-        if (typeof key === "function") {
-            return key(item);
-        }
-        return item != null ? item[key] : null;
-    };
-    const arrayUniqueByKey = [
-        ...new Map(objects.map((item)=>[
-                getKey(key, item),
-                item
-            ])).values()
-    ];
-    return arrayUniqueByKey;
-}

package/es6/src/composition/index.js

@@ -1 +0,0 @@
-export { };

package/es6/src/configuration/configuration.types.js

@@ -1 +0,0 @@
-export const ConfigurationServiceToken = Symbol("IConfigurationService");

package/es6/src/extensibility/decorator-factory.js

@@ -1,21 +0,0 @@
-/**
- * Decorator factory class that provides decorator methods which can be conditionally
- * disabled during unit testing using the @ignoreInUnitTest decorator.
- *
- * Inspired by: https://jasonharper.blog/2018/03/13/decorate-the-decorator-to-exclude-in-unit-testing/
- */ /**
- * Decorator that disables the decorated decorator method when TEST environment variable is true.
- * If TEST=true, it returns a no-op decorator that simply returns the original function unchanged.
- */ export function ignoreInUnitTest(_target, _propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    descriptor.value = function(...args) {
-        // Check if we're in a test environment
-        if (process.env.TEST === "true") {
-            // Return a no-op decorator that just returns the original function
-            return (originalFunction)=>originalFunction;
-        }
-        // Otherwise, apply the original decorator method
-        return originalMethod.apply(this, args);
-    };
-    return descriptor;
-}

package/es6/src/extensibility/extension.js

@@ -1,27 +0,0 @@
-export function extension(ctor, options) {
-    return (_target, propertyKey, descriptor)=>{
-        const originalFunction = descriptor.value;
-        ctor.prototype[propertyKey] = function(...args) {
-            return originalFunction.apply(this, [
-                this,
-                ...args
-            ]);
-        };
-        if (options?.static) {
-            Object.defineProperty(ctor, propertyKey, {
-                configurable: true,
-                writable: true,
-                value (...args) {
-                    const receiver = singletonOf(ctor) ?? this;
-                    return originalFunction.apply(receiver, [
-                        receiver,
-                        ...args
-                    ]);
-                }
-            });
-        }
-    };
-}
-function singletonOf(ctor) {
-    return ctor.instance;
-}

package/es6/src/extensibility/mixwith.js

@@ -1,26 +0,0 @@
-const BLOCKED_PROTOTYPE_KEYS = new Set([
-    "constructor",
-    "prototype",
-    "name",
-    "length"
-]);
-function copyPrototypeProperties(target, source) {
-    for (const key of Reflect.ownKeys(source)){
-        if (typeof key === "string" && BLOCKED_PROTOTYPE_KEYS.has(key)) {
-            continue;
-        }
-        const descriptor = Object.getOwnPropertyDescriptor(source, key);
-        if (descriptor == null) {
-            continue;
-        }
-        Object.defineProperty(target, key, descriptor);
-    }
-}
-export function mixwith(...mixins) {
-    class Mixed {
-    }
-    for (const mixin of mixins){
-        copyPrototypeProperties(Mixed.prototype, mixin.prototype);
-    }
-    return Mixed;
-}

package/es6/src/extensibility/pipeline.js

@@ -1,46 +0,0 @@
-import { scribe } from "@decohere/scribe";
-export class Pipeline {
-    stack;
-    logger = scribe.logger(Pipeline.name);
-    currentStep;
-    constructor(...steps){
-        this.stack = steps;
-    }
-    [Symbol.dispose]() {
-        for (const [, step] of this.stack){
-            if (Symbol.dispose in step) {
-                step[Symbol.dispose]();
-            }
-        }
-    }
-    async start(context) {
-        const runStep = async (index)=>{
-            const [key, middleware, when] = this.stack[index] ?? [];
-            if (middleware == null) {
-                return;
-            }
-            if (when != null && !when(context)) {
-                this.logger.info(`Skipping step ${key}`);
-                return await runStep(index + 1);
-            }
-            this.currentStep = key;
-            this.logger.info(`Running step ${key}`);
-            await middleware.run(context, async ()=>{
-                await runStep(index + 1);
-            });
-        };
-        try {
-            await runStep(0);
-        } catch (error) {
-            const step = this.currentStep ?? "unknown";
-            if (error instanceof Error) {
-                throw new Error(`Pipeline step '${step}' failed: ${error.message}`, {
-                    cause: error
-                });
-            }
-            throw new Error(`Pipeline step '${step}' failed with non-Error value`, {
-                cause: error
-            });
-        }
-    }
-}

package/es6/src/extensibility/step.js

@@ -1,16 +0,0 @@
-/**
- * Wraps a pipeline step with an optional `when` predicate.
- * When `when` is provided, the step only runs if `when(ctx)` returns `true`.
- * If `when` returns `false`, the pipeline logs `"Skipping step <name>"` and
- * advances to the next step without invoking `run()`.
- *
- * Predicates are declared in the command constructor via `addDisableStepOption`,
- * keeping skip conditions co-located with the option that controls them.
- */ export class Step {
-    type;
-    when;
-    constructor(type, when){
-        this.type = type;
-        this.when = when;
-    }
-}

package/es6/src/io/copy-file.js

@@ -1,10 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export async function copyFile(src, dest, options = {}) {
-    if (options.mkdir) {
-        await fs.mkdir(path.dirname(dest), {
-            recursive: true
-        });
-    }
-    await fs.copyFile(src, dest);
-}

package/es6/src/io/delete-file.js

@@ -1,6 +0,0 @@
-import fs from "node:fs/promises";
-export async function deleteFile(filePath) {
-    return fs.rm(filePath, {
-        force: true
-    });
-}

package/es6/src/io/directory-exists.js

@@ -1,9 +0,0 @@
-import fs from "node:fs/promises";
-export async function directoryExists(path) {
-    try {
-        await fs.access(path);
-        return true;
-    } catch  {
-        return false;
-    }
-}

package/es6/src/io/file-exists.js

@@ -1,9 +0,0 @@
-import { stat } from "node:fs/promises";
-export async function fileExists(path) {
-    try {
-        const stats = await stat(path);
-        return stats.isFile();
-    } catch  {
-        return false;
-    }
-}

package/es6/src/io/read-file.js

@@ -1,13 +0,0 @@
-import fs from "node:fs/promises";
-export async function readFiles(filePaths, encoding = "utf8") {
-    const data = await Promise.all(filePaths.map((file)=>readFile(file.fullPath, encoding)));
-    return data;
-}
-export async function readFile(filePath, encoding = "utf8") {
-    const data = await fs.readFile(filePath, encoding);
-    return data;
-}
-export async function readJsonFile(filePath, encoding = "utf8") {
-    const data = await readFile(filePath, encoding);
-    return JSON.parse(data);
-}

package/es6/src/io/remove-dir.js

@@ -1,7 +0,0 @@
-import fs from "node:fs/promises";
-export async function removeDir(path, options = {
-    recursive: false,
-    force: false
-}) {
-    await fs.rm(path, options);
-}

package/es6/src/io/types/directory.type.js

@@ -1 +0,0 @@
-export { };

package/es6/src/io/types/file.js

@@ -1,18 +0,0 @@
-import { readFile } from "../read-file.js";
-export class FileEx {
-    constructor(data){
-        this.fullPath = data.fullPath;
-        this.relativePath = data.relativePath ?? data.fullPath;
-        this.#content = data.content;
-    }
-    #content;
-    fullPath;
-    relativePath;
-    toString() {
-        return this.relativePath;
-    }
-    async getContent() {
-        if (this.#content != null) return this.#content;
-        return readFile(this.fullPath);
-    }
-}

package/es6/src/io/url-to-path.js

@@ -1,15 +0,0 @@
-import { fileURLToPath, pathToFileURL } from "node:url";
-export const fileUrlToPath = (url)=>{
-    try {
-        return fileURLToPath(url);
-    } catch  {
-        return url;
-    }
-};
-export const pathToFileUrl = (path)=>{
-    try {
-        return pathToFileURL(path).toString();
-    } catch  {
-        return path;
-    }
-};

package/es6/src/io/write-file.js

@@ -1,15 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export async function writeFile(filePath, content, options = {
-    encoding: "utf8",
-    mkdir: false
-}) {
-    const { encoding, mkdir } = options;
-    if (mkdir) {
-        const directory = path.dirname(filePath);
-        await fs.mkdir(directory, {
-            recursive: true
-        });
-    }
-    await fs.writeFile(filePath, content, encoding);
-}