assign-gingerly 0.0.74 → 0.0.75

package/inferencer/types/assign-gingerly/types.d.ts

@@ -591,21 +591,6 @@ export interface SupportedFeatureConfig {
     callbackForwarding?: string[];
 }
 
-/**
- * Class-level configuration for the features system.
- * Declared as `static featuresConfig` on the class.
- */
-export interface FeaturesClassConfig {
-    /**
-     * Lifecycle method configuration.
-     * true = install 'whenFeatureReady' method.
-     * Object = custom method name.
-     */
-    lifecycleKeys?: true | {
-        whenFeatureReady?: string;
-    };
-}
-
 /**
  * Configuration for a feature passed to assignFeatures.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.74",
+  "version": "0.0.75",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -21,6 +21,7 @@
     "assignPermissions/**",
     "handlers/**",
     "inferencer/**",
+    "utils/**",
     "README.md",
     "LICENSE",
     "types/assign-gingerly/types.d.ts"

package/utils/findClassPrototypeInPath.js

@@ -0,0 +1,57 @@
+import { isAllowedImportPath } from '../assignPermissions/isAllowedImportPath.js';
+/**
+ * Thrown when a dynamic import path is not covered by the allowed-import policy.
+ */
+export class ImportNotAllowedError extends Error {
+    path;
+    constructor(path) {
+        super(`Import path "${path}" is not allowed.`);
+        this.path = path;
+        this.name = 'ImportNotAllowedError';
+        console.error(`ImportNotAllowedError: ${path}`);
+    }
+}
+/**
+ * Thrown when a module does not export a class that satisfies the required criteria.
+ */
+export class NoMatchingExportError extends Error {
+    path;
+    constructor(path) {
+        super(`Module "${path}" does not export a matching class with a prototype.`);
+        this.path = path;
+        this.name = 'NoMatchingExportError';
+        console.error(`NoMatchingExportError: ${path}`);
+    }
+}
+/**
+ * Base check: value must be a function with a prototype (i.e., a class constructor).
+ */
+function isClassWithPrototype(value) {
+    return typeof value === 'function' && value.prototype !== undefined;
+}
+/**
+ * Dynamically import a module at the given path, validate the path against the
+ * allowed-import policy, and return the first exported class whose prototype passes
+ * the optional criteria check.
+ *
+ * The default export is checked first. If it does not satisfy the checks, all named
+ * exports are scanned. If no matching class is found, a `NoMatchingExportError` is thrown.
+ */
+export async function findClassPrototypeInPath(path, criteria) {
+    if (!isAllowedImportPath(path)) {
+        throw new ImportNotAllowedError(path);
+    }
+    const module = await import(path);
+    const candidates = [
+        module.default,
+        ...Object.values(module).filter((exported) => exported !== module.default),
+    ];
+    for (const exported of candidates) {
+        if (!isClassWithPrototype(exported))
+            continue;
+        if (criteria && !criteria(exported))
+            continue;
+        return exported;
+    }
+    throw new NoMatchingExportError(path);
+}

package/utils/findClassPrototypeInPath.ts

@@ -0,0 +1,62 @@
+import { isAllowedImportPath } from '../assignPermissions/isAllowedImportPath.js';
+
+/**
+ * Thrown when a dynamic import path is not covered by the allowed-import policy.
+ */
+export class ImportNotAllowedError extends Error {
+    constructor(public readonly path: string) {
+        super(`Import path "${path}" is not allowed.`);
+        this.name = 'ImportNotAllowedError';
+        console.error(`ImportNotAllowedError: ${path}`);
+    }
+}
+
+/**
+ * Thrown when a module does not export a class that satisfies the required criteria.
+ */
+export class NoMatchingExportError extends Error {
+    constructor(public readonly path: string) {
+        super(`Module "${path}" does not export a matching class with a prototype.`);
+        this.name = 'NoMatchingExportError';
+        console.error(`NoMatchingExportError: ${path}`);
+    }
+}
+
+/**
+ * Base check: value must be a function with a prototype (i.e., a class constructor).
+ */
+function isClassWithPrototype(value: any): boolean {
+    return typeof value === 'function' && value.prototype !== undefined;
+}
+
+/**
+ * Dynamically import a module at the given path, validate the path against the
+ * allowed-import policy, and return the first exported class whose prototype passes
+ * the optional criteria check.
+ *
+ * The default export is checked first. If it does not satisfy the checks, all named
+ * exports are scanned. If no matching class is found, a `NoMatchingExportError` is thrown.
+ */
+export async function findClassPrototypeInPath<T = any>(
+    path: string,
+    criteria?: (proto: any) => boolean
+): Promise<{ new(): T }> {
+    if (!isAllowedImportPath(path)) {
+        throw new ImportNotAllowedError(path);
+    }
+
+    const module = await import(path);
+
+    const candidates = [
+        module.default,
+        ...Object.values(module).filter((exported: any) => exported !== module.default),
+    ];
+
+    for (const exported of candidates) {
+        if (!isClassWithPrototype(exported)) continue;
+        if (criteria && !criteria(exported)) continue;
+        return exported as { new(): T };
+    }
+
+    throw new NoMatchingExportError(path);
+}

package/utils/isAsyncSpawn.js

@@ -0,0 +1,20 @@
+/**
+ * Determines if a function is an async spawner (returns a Promise<Constructor>)
+ * rather than a synchronous constructor.
+ *
+ * Heuristic:
+ * - AsyncFunction (async () => ...) → async spawner
+ * - Arrow function (no .prototype) → async spawner (assumed to return Promise<Constructor>)
+ * - Class or function declaration (has .prototype) → synchronous constructor
+ */
+export function isAsyncSpawn(fn) {
+    if (typeof fn !== 'function')
+        return false;
+    // Explicit async function
+    if (fn.constructor.name === 'AsyncFunction')
+        return true;
+    // Arrow function or non-constructor function (no .prototype)
+    if (fn.prototype === undefined)
+        return true;
+    return false;
+}

package/utils/isAsyncSpawn.ts

@@ -0,0 +1,17 @@
+/**
+ * Determines if a function is an async spawner (returns a Promise<Constructor>)
+ * rather than a synchronous constructor.
+ *
+ * Heuristic:
+ * - AsyncFunction (async () => ...) → async spawner
+ * - Arrow function (no .prototype) → async spawner (assumed to return Promise<Constructor>)
+ * - Class or function declaration (has .prototype) → synchronous constructor
+ */
+export function isAsyncSpawn(fn: any): boolean {
+    if (typeof fn !== 'function') return false;
+    // Explicit async function
+    if (fn.constructor.name === 'AsyncFunction') return true;
+    // Arrow function or non-constructor function (no .prototype)
+    if (fn.prototype === undefined) return true;
+    return false;
+}