{"version":3,"sources":["../src/classs/createMagicClass.ts"],"names":["isMagicClassOptions","args","params","createMagicClass","classBase","options","onBeforeInstance","onAfterInstance","onErrorInstance","defaultParams","handleParameters","parentParms","len","_","i","param","isPlainObject","makeInheritable","ctor","createCallWrapper","Wrapper","bindWrapper","newWrapper","newArgs","isMagicing","instance","finalArgs","result","isClass","e"],"mappings":"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","file":"chunk-PGSXHH3O.mjs","sourcesContent":["import { isPlainObject } from '../typecheck'\nimport { isClass } from '../typecheck/isClass'\nimport type { Class, Fallback } from '../types'\n\ntype StrictTuple<T> = T extends readonly [...infer E] ? E : [...never]\n\n/**\n * 表示一个魔术类构造函数，既可以作为构造函数使用，也可以作为函数调用来配置选项\n * @template Base 基础类类型\n * @template Options 配置选项类型\n */\n/**\n * 表示一个魔术类构造函数，既可以作为构造函数使用，也可以作为函数调用来配置选项\n * @template Base 基础类类型\n * @template Options 配置选项类型\n */\nexport interface MagicClassConstructor<Base extends Class, Args = ConstructorParameters<Base>> {\n    /** 作为构造函数使用，创建基础类的实例 */\n    new (...args: StrictTuple<Args>): InstanceType<Base>\n    /** 作为函数调用，配置选项并返回配置后的构造函数 */\n    <RefArgs = never>(\n        ...args: StrictTuple<Args>\n    ): MagicClassConstructor<Base, Fallback<RefArgs, Args>>\n    <RefArgs = never>(\n        createOptions: CreateMagicClassOptions<Base, RefArgs>,\n    ): MagicClassConstructor<Base, Fallback<RefArgs, Args>>\n    /** 原型属性，继承自基础类 */\n    prototype: InstanceType<Base>\n}\n\n/**\n * 创建魔术类的配置选项\n * @template Base 基础类类型\n * @template Options 扩展配置选项类型\n */\nexport type CreateMagicClassOptions<\n    Base extends Class,\n    RefParams = ConstructorParameters<Base>,\n    Params = ConstructorParameters<Base>,\n> = {\n    // 处理类构造参数\n    params?: Params | ((params: RefParams, scopeParms: Params) => Params)\n    /** 实例创建前的钩子函数，可以阻止实例创建或修改类 */\n    onBeforeInstance?: (cls: Base, params: Params) => void | boolean | object\n    /** 实例创建后的钩子函数 */\n    onAfterInstance?: (inst: InstanceType<Base>) => void\n    /** 实例创建出错时的钩子函数 */\n    onErrorInstance?: (error: Error, cls: Base, params: Params) => void\n}\n\nexport type MagicClassScope = CreateMagicClassOptions<any> & {\n    __MAGIC_CLASS_SCOPE: boolean\n    finalParams: any[]\n}\n\nfunction isMagicClassOptions(args: any[]): boolean {\n    if (args.length !== 1) return false\n    const params = args[0] as CreateMagicClassOptions<any>\n    return (\n        typeof params === 'object' &&\n        ('params' in params ||\n            'onBeforeInstance' in params ||\n            'onAfterInstance' in params ||\n            'onErrorInstance' in params)\n    )\n}\n\n/**\n * 创建一个魔术类，该类既可以作为构造函数使用，也可以作为函数调用来配置选项\n *\n * 魔术类具有以下特性：\n * 1. 可以作为构造函数使用：`new MagicClass(...args)`\n * 2. 可以作为函数调用来配置选项：`MagicClass(options)`，返回配置后的构造函数\n * 3. 支持生命周期钩子：onBeforeInstance、onAfterInstance、onErrorInstance\n *\n * @template BaseClass 基础类类型\n * @template Options 配置选项类型\n * @param classBase 要包装的基础类\n * @param options 创建魔术类的配置选项\n * @returns 魔术类构造函数\n *\n * @example\n * // 基本用法\n * class MyClass {\n *   constructor(name: string) {\n *     this.name = name;\n *   }\n * }\n *\n * const MagicMyClass = createMagicClass(MyClass);\n * const instance = new MagicMyClass(\"test\");\n *\n * @example\n * // 使用配置选项\n * const MagicMyClass = createMagicClass(MyClass, {\n *   onBeforeInstance: (cls, args, options) => {\n *     console.log(\"Before instance creation\", args);\n *   },\n *   onAfterInstance: (instance, options) => {\n *     console.log(\"Instance created\", instance);\n *   }\n * });\n *\n * // 函数调用配置\n * const ConfiguredClass = MagicMyClass({ extraOption: true });\n * const instance = new ConfiguredClass(\"test\");\n */\nexport function createMagicClass<BaseClass extends Class>(\n    classBase: BaseClass,\n    options?: CreateMagicClassOptions<BaseClass>,\n) {\n    type Params = ConstructorParameters<BaseClass>\n    const { params, onBeforeInstance, onAfterInstance, onErrorInstance } = Object.assign(\n        {},\n        options,\n    )\n\n    const defaultParams = Array.isArray(params) ? params : undefined\n\n    // 默认的参数合并方式\n    const defaultHandleParams = (params: Params, parentParms: Params | undefined): Params => {\n        const len = Math.max(params.length, parentParms?.length || 0)\n        return Array.from({ length: len }).map((_, i) => {\n            const param = params[i]\n            if (isPlainObject(param)) {\n                return Object.assign({}, defaultParams?.[i], parentParms?.[i], param)\n            } else {\n                return param || parentParms?.[i] || defaultParams?.[i]\n            }\n        }) as Params\n    }\n    const handleParameters = (\n        typeof params === 'function' ? params : defaultHandleParams\n    ) as Function\n\n    function makeInheritable<T extends Function>(ctor: T): T {\n        function createCallWrapper(Wrapper: any, ...args: any[]) {\n            if (isMagicClassOptions(args)) {\n                return createMagicClass(Wrapper, Object.assign({}, options, args[0]))\n            }\n            const bindWrapper = Wrapper.bind(null)\n            bindWrapper.prototype = Wrapper.prototype\n            const newWrapper = function (this: any, ...args: Params) {\n                if (isMagicClassOptions(args)) {\n                    return createMagicClass(bindWrapper, args[0])\n                }\n                const handleParams =\n                    newWrapper._magic_class_options?.paramHandler || handleParameters\n                const newArgs = handleParams(args, newWrapper._magic_class_options.params) as Params\n                if (!new.target) {\n                    return createCallWrapper(bindWrapper, ...newArgs)\n                }\n                return new bindWrapper(...newArgs)\n            }\n            // 魔术类选项\n            newWrapper._magic_class_options = Object.assign(\n                {},\n                options,\n                {\n                    paramHandler: handleParameters,\n                    params: handleParameters(args, defaultParams),\n                },\n                Wrapper._magic_class_options,\n            )\n            newWrapper.prototype = bindWrapper.prototype\n            Object.defineProperty(newWrapper, 'name', {\n                value: ctor.name,\n                configurable: true,\n            })\n            return newWrapper\n        }\n        function Wrapper(this: any, ...args: any[]) {\n            if (!new.target) {\n                // 函数调用方式\n                return createCallWrapper(Wrapper, ...arguments)\n            }\n            //@ts-expect-error\n            const isMagicing: boolean = new.target._magicing ?? false\n            let instance: any\n            // @ts-expect-error\n            const finalArgs = new.target._magicing ? args : handleParameters(args, defaultParams)\n\n            try {\n                if (typeof onBeforeInstance === 'function' && !isMagicing) {\n                    const result = onBeforeInstance(\n                        new.target as unknown as BaseClass,\n                        finalArgs as any,\n                    )\n                    if (result === false) {\n                        throw new Error('createMagicClass is blocked by onBeforeInstance hook')\n                    } else if (isClass(result)) {\n                        // 替换构造函数\n                        instance = Reflect.construct(result as unknown as T, finalArgs)\n                    } else if (result !== undefined) {\n                        instance = result\n                    }\n                }\n\n                if (!instance) {\n                    // 创建实例\n                    // @ts-expect-error\n                    new.target._magicing = true\n                    instance = Reflect.construct(ctor, finalArgs, new.target)\n                }\n\n                // 调用onAfterInstance钩子\n                if (typeof onAfterInstance === 'function' && !isMagicing) {\n                    onAfterInstance(instance)\n                }\n                return instance\n            } catch (e: any) {\n                if (typeof onErrorInstance === 'function' && !isMagicing) {\n                    onErrorInstance(e, new.target as unknown as BaseClass, finalArgs)\n                }\n                throw e // 重新抛出错误，确保错误能够传播\n            } finally {\n                // @ts-expect-error\n                new.target._magicing = false\n            }\n        }\n        Wrapper.prototype = ctor.prototype\n        Object.defineProperty(Wrapper, 'name', {\n            value: ctor.name,\n            configurable: true,\n        })\n        return Wrapper as unknown as T\n    }\n    return makeInheritable(\n        classBase as unknown as any,\n    ) as unknown as MagicClassConstructor<BaseClass>\n}\n"]}