@decohere/core 0.0.1-dev.116

package/commonjs/src/cli/options.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ConfigFileOption () {
+        return ConfigFileOption;
+    },
+    get ConfigurationOption () {
+        return ConfigurationOption;
+    },
+    get DryRunOption () {
+        return DryRunOption;
+    },
+    get EnvFileIfExistsOption () {
+        return EnvFileIfExistsOption;
+    },
+    get EnvFileOption () {
+        return EnvFileOption;
+    },
+    get LogLevelOption () {
+        return LogLevelOption;
+    },
+    get NoBuildOptions () {
+        return NoBuildOptions;
+    },
+    get NoCleanOptions () {
+        return NoCleanOptions;
+    },
+    get ProjectOption () {
+        return ProjectOption;
+    }
+});
+const _commander = require("commander");
+function parseOptionalBoolean(input) {
+    if (typeof input === "boolean") {
+        return input;
+    }
+    const value = input.trim().toLowerCase();
+    if ([
+        "true",
+        "1",
+        "yes",
+        "on"
+    ].includes(value)) {
+        return true;
+    }
+    if ([
+        "false",
+        "0",
+        "no",
+        "off"
+    ].includes(value)) {
+        return false;
+    }
+    throw new Error(`Invalid boolean value: "${input}". Use true/false.`);
+}
+class ConfigurationOption extends _commander.Option {
+    constructor(defaultValue){
+        super("--configuration <configuration>", "Configuration name");
+        this.default(defaultValue);
+    }
+}
+class ConfigFileOption extends _commander.Option {
+    constructor(defaultValue = ".decohere.js"){
+        super("--config-file <file>", "Path to Decohere config file");
+        this.default(defaultValue);
+    }
+}
+class LogLevelOption extends _commander.Option {
+    constructor(){
+        super("--log-level <level>", "Log level (trace, debug, info, warn, error)");
+    }
+}
+class EnvFileOption extends _commander.Option {
+    constructor(){
+        super("--env-file <file>", "Load environment variables from this file before running");
+    }
+}
+class EnvFileIfExistsOption extends _commander.Option {
+    constructor(){
+        super("--env-file-if-exists <file>", "Like --env-file, but skip it when the file is missing");
+    }
+}
+class NoCleanOptions extends _commander.Option {
+    constructor(defaultValue){
+        super("--no-clean", "Will not clean the project directories");
+        this.default(defaultValue);
+    }
+}
+class NoBuildOptions extends _commander.Option {
+    constructor(defaultValue){
+        super("--no-build", "Will not run the build step");
+        this.default(defaultValue);
+    }
+}
+class DryRunOption extends _commander.Option {
+    constructor(description, defaultValue = false){
+        super("--dry-run [dryRun]", description);
+        this.default(defaultValue);
+        this.preset(true);
+        this.argParser(parseOptionalBoolean);
+    }
+}
+class ProjectOption extends _commander.Option {
+    constructor(){
+        super("--project <project>", "Project name to target");
+    }
+}

package/commonjs/src/collections/collections.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./find-duplicates.js"), exports);
+_export_star(require("./merge-arrays.js"), exports);
+_export_star(require("./sum.js"), exports);
+_export_star(require("./unique-objects.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get findDuplicatesBy () {
+        return findDuplicatesBy;
+    },
+    get findDuplicatesByKey () {
+        return findDuplicatesByKey;
+    }
+});
+function findDuplicatesByKey(items, key) {
+    return findDuplicatesBy(items, (item)=>String(item[key]));
+}
+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/commonjs/src/collections/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "collections", {
+    enumerable: true,
+    get: function() {
+        return _collections;
+    }
+});
+const _collections = /*#__PURE__*/ _interop_require_wildcard(require("./collections.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get mergeBy () {
+        return mergeBy;
+    },
+    get mergeByKey () {
+        return mergeByKey;
+    }
+});
+function mergeByKey(first, second, key) {
+    return mergeBy(first, second, (item)=>String(item[key]));
+}
+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/commonjs/src/collections/sum.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get sumBy () {
+        return sumBy;
+    },
+    get sumByKey () {
+        return sumByKey;
+    }
+});
+function sumByKey(objects, key) {
+    return sum(objects, key);
+}
+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/commonjs/src/collections/unique-objects.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get uniqueObjectsBy () {
+        return uniqueObjectsBy;
+    },
+    get uniqueObjectsByKey () {
+        return uniqueObjectsByKey;
+    }
+});
+function uniqueObjectsByKey(objects, key) {
+    return uniqueObjects(objects, key);
+}
+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/commonjs/src/composition/index.js

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

package/commonjs/src/configuration/configuration.types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConfigurationServiceToken", {
+    enumerable: true,
+    get: function() {
+        return ConfigurationServiceToken;
+    }
+});
+const ConfigurationServiceToken = Symbol("IConfigurationService");

package/commonjs/src/configuration/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./configuration.types.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/commonjs/src/diagnostics/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Trace () {
+        return _trace.Trace;
+    },
+    get timed () {
+        return _trace.timed;
+    },
+    get trace () {
+        return _trace.trace;
+    }
+});
+const _trace = require("./trace.js");

package/commonjs/src/diagnostics/trace.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Trace () {
+        return Trace;
+    },
+    get timed () {
+        return timed;
+    },
+    get trace () {
+        return trace;
+    }
+});
+const _types = require("node:util/types");
+const _scribe = require("@decohere/scribe");
+// Keep existing behavior for now: trace mode is toggled via FORGE_TRACE.
+const isTraceEnabled = process.env.FORGE_TRACE != null;
+if (isTraceEnabled) {
+    const hasExplicitLevel = process.env.LOG_LEVEL != null || process.env.SCRIBE_LOG_LEVEL != null || process.env.LOGGING_LEVEL != null;
+    if (!hasExplicitLevel) {
+        _scribe.scribe.configure({
+            adapter: new _scribe.ConsoleAdapter(),
+            options: {
+                logLevel: "trace"
+            }
+        });
+    }
+}
+function serializeArgs(args) {
+    if (args.length === 0) return "";
+    return args.map((arg)=>{
+        if (Array.isArray(arg)) return `[${arg.map(String).join(", ")}]`;
+        const s = String(arg);
+        return s.length > 60 ? `${s.slice(0, 57)}...` : s;
+    }).join(", ");
+}
+function wrapWithTiming(fn, className, methodName, logLevel) {
+    let logger;
+    return function(...args) {
+        if (logger == null) {
+            logger = _scribe.scribe.logger(className);
+        }
+        const log = logger;
+        const label = `${methodName}(${serializeArgs(args)})`;
+        const start = performance.now();
+        const logDuration = ()=>{
+            log[logLevel](`${label}: ${(performance.now() - start).toFixed(2)}ms`);
+        };
+        const result = fn.apply(this, args);
+        if ((0, _types.isPromise)(result)) {
+            return result.finally(logDuration);
+        }
+        logDuration();
+        return result;
+    };
+}
+function trace(target, propertyKey, descriptor) {
+    if (!isTraceEnabled) return descriptor;
+    const className = target.constructor.name;
+    descriptor.value = wrapWithTiming(descriptor.value, className, propertyKey, "trace");
+    return descriptor;
+}
+function timed(target, propertyKey, descriptor) {
+    const className = target.constructor.name;
+    descriptor.value = wrapWithTiming(descriptor.value, className, propertyKey, "info");
+    return descriptor;
+}
+function Trace(constructor) {
+    if (!isTraceEnabled) return;
+    const className = constructor.name;
+    for (const key of Object.getOwnPropertyNames(constructor.prototype)){
+        if (key === "constructor") continue;
+        const descriptor = Object.getOwnPropertyDescriptor(constructor.prototype, key);
+        if (descriptor == null || typeof descriptor.value !== "function") continue;
+        descriptor.value = wrapWithTiming(descriptor.value, className, key, "trace");
+        Object.defineProperty(constructor.prototype, key, descriptor);
+    }
+}

package/commonjs/src/extensibility/decorator-factory-base.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DecoratorFactoryBase", {
+    enumerable: true,
+    get: function() {
+        return DecoratorFactoryBase;
+    }
+});
+class DecoratorFactoryBase {
+    /**
+	 * Utility method to check if we're currently in a test environment
+	 */ isTestEnvironment() {
+        return process.env.TEST === "true";
+    }
+    /**
+	 * Creates a no-op decorator that returns the original function unchanged
+	 */ createNoOpDecorator() {
+        return (_target, _propertyKey, descriptor)=>descriptor;
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ignoreInUnitTest", {
+    enumerable: true,
+    get: function() {
+        return ignoreInUnitTest;
+    }
+});
+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/commonjs/src/extensibility/extension.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "extension", {
+    enumerable: true,
+    get: function() {
+        return extension;
+    }
+});
+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/commonjs/src/extensibility/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./decorator-factory.js"), exports);
+_export_star(require("./decorator-factory-base.js"), exports);
+_export_star(require("./extension.js"), exports);
+_export_star(require("./mixwith.js"), exports);
+_export_star(require("./pipeline.js"), exports);
+_export_star(require("./step.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/commonjs/src/extensibility/mixwith.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mixwith", {
+    enumerable: true,
+    get: function() {
+        return mixwith;
+    }
+});
+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);
+    }
+}
+function mixwith(...mixins) {
+    class Mixed {
+    }
+    for (const mixin of mixins){
+        copyPrototypeProperties(Mixed.prototype, mixin.prototype);
+    }
+    return Mixed;
+}