Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | 1x 1x 1x 1x 1x 1x 1x 1x 68x 68x 68x 68x 68x 68x 68x 68x 1x 1x 1x 1x 1x 1x 1x 1x 1x 83x 83x 83x 83x 83x 83x 83x 83x 83x 302x 302x 302x 302x 302x 302x 5x 4x 4x 4x 4x 4x 5x 5x 302x 68x 5x 5x 5x 5x 5x 5x 5x 5x 68x 234x 234x 302x 302x 302x 302x 302x 302x 302x 302x 302x 302x 302x 302x 302x 140x 140x 302x 302x 83x 83x | import type {Adapter, ILib, IMeta} from '@feasibleone/blong/types';
import merge from 'ut-function.merge';
import {camelToSentence, parseAnnotatedKey} from './lib.ts';
/**
* Rename a function's `.name` property.
*/
function rename<T>(value: string, fn: T): T {
Object.defineProperty(fn, 'name', {
value,
configurable: true,
enumerable: false,
});
return fn;
}
/**
* Create the handler proxy — the IoC mechanism that resolves handler calls
* at runtime through the registry (local or remote).
*
* This is the most important abstraction in the framework: handlers never
* import each other directly; they access dependencies through this proxy.
*/
export default function createHandlerProxy(
local: object,
port: Adapter,
remote: (methodName: string) => () => unknown,
attachCheckpoint: ((meta: IMeta) => void) | undefined,
lib: ILib,
mergedConfig: Record<string, unknown>,
): object {
return new Proxy(local, {
get(target: unknown, handlerName: string) {
if (typeof handlerName !== 'string') return undefined;
function resolveHandler(resolvedName: string): (...params: unknown[]) => unknown {
let fn: (() => unknown) | undefined;
const sentence = camelToSentence(resolvedName);
function nameSteps(result: unknown): unknown {
if (Array.isArray(result) && !(result as {name?: string}).name) {
Object.defineProperty(result, 'name', {
value: sentence,
configurable: true,
});
}
return result;
}
if (port?.handles?.(resolvedName)) {
return rename(resolvedName, function (...params: unknown[]) {
fn ||= port.findHandler?.(resolvedName) as (() => unknown) | undefined;
if (!fn) throw new Error(`Handler '${resolvedName}' not found`);
const $meta = params.length > 1 ? (params[1] as IMeta) : undefined;
if ($meta && typeof $meta === 'object') {
attachCheckpoint?.($meta);
}
return nameSteps(fn.apply(port, params as []));
});
}
return remote(resolvedName);
}
function wrapWithMeta(
baseFn: (...params: unknown[]) => unknown,
metaOverrides: Record<string, unknown>,
aliasName?: string,
): (...params: unknown[]) => unknown {
return rename(aliasName || baseFn.name, function (...params: unknown[]) {
const $meta = params.length > 1 ? (params[1] as IMeta) : undefined;
if ($meta && typeof $meta === 'object') {
merge($meta, metaOverrides);
}
const result = baseFn(...params);
if (Array.isArray(result) && metaOverrides.name) {
Object.defineProperty(result, 'name', {
value: metaOverrides.name,
configurable: true,
});
}
return result;
});
}
// Approach 2: Annotation syntax
if (handlerName.startsWith('@')) {
const parsed = parseAnnotatedKey(handlerName);
const baseFn = resolveHandler(parsed.handlerName);
const metaOverrides: Record<string, unknown> = {};
for (const ann of parsed.annotations) {
const hasKeyValue = ann.params.some(p => p.includes('='));
if (ann.params.length > 0 && !hasKeyValue) {
// Mode A: $meta injection
metaOverrides[ann.name] = ann.params.join(' ');
} else {
// Mode B: config-object reference with deep merge
const handlerConfig = mergedConfig?.handler as
| Record<string, unknown>
| undefined;
const configObj = handlerConfig?.[ann.name];
if (configObj && typeof configObj === 'object') {
merge(metaOverrides, configObj as Record<string, unknown>);
}
for (const p of ann.params) {
const eqIdx = p.indexOf('=');
if (eqIdx > 0) {
lib.setProperty(
metaOverrides,
p.slice(0, eqIdx),
p.slice(eqIdx + 1),
);
}
}
}
}
return wrapWithMeta(baseFn, metaOverrides);
}
// Resolve handler (local or remote)
const resolved = resolveHandler(handlerName);
// Approach 1: Wrap with naming proxy for sub-property destructuring
return new Proxy(resolved, {
get(proxyTarget, prop, receiver) {
if (typeof prop !== 'string' || prop in proxyTarget) {
return Reflect.get(proxyTarget, prop, receiver);
}
return wrapWithMeta(
proxyTarget as (...params: unknown[]) => unknown,
{
name: camelToSentence(prop),
},
prop,
);
},
apply(proxyTarget, thisArg, args) {
return Reflect.apply(proxyTarget, thisArg, args);
},
});
},
});
}
|