evil-vue
Version:
Evil vue3 writing, similar to angular writing Dependency injection
1,183 lines (1,182 loc) • 43.4 kB
JavaScript
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
import { InjectionToken, ReflectiveInjector, Injectable, Inject, forwardRef, Optional } from "injection-js";
export * from "injection-js";
import { createApp, inject, provide, getCurrentInstance, onBeforeMount, onMounted, onBeforeUpdate, onUpdated, onBeforeUnmount, onUnmounted, onErrorCaptured, onRenderTracked, onRenderTriggered, onActivated, onDeactivated, ref, computed, h, createVNode } from "vue";
import { RouterView, createRouter, useRouter, useRoute } from "vue-router";
import axios from "axios";
const Metadata = new WeakMap();
function decorateProperty(decorators, target, propertyKey, descriptor) {
decorators.reverse().forEach((decorator) => {
descriptor = decorator(target, propertyKey, descriptor) || descriptor;
});
return descriptor;
}
function decorateConstructor(decorators, target) {
decorators.reverse().forEach((decorator) => {
const decorated = decorator(target);
if (decorated) {
target = decorated;
}
});
return target;
}
function decorate(decorators, target, propertyKey, attributes) {
if (!Array.isArray(decorators) || decorators.length === 0) {
throw new TypeError();
}
if (propertyKey !== void 0) {
return decorateProperty(decorators, target, propertyKey, attributes);
}
if (typeof target === "function") {
return decorateConstructor(decorators, target);
}
return;
}
function getMetadataMap(target, propertyKey) {
return Metadata.get(target) && Metadata.get(target).get(propertyKey);
}
function ordinaryGetOwnMetadata(metadataKey, target, propertyKey) {
if (target === void 0) {
throw new TypeError();
}
const metadataMap = getMetadataMap(target, propertyKey);
return metadataMap && metadataMap.get(metadataKey);
}
function createMetadataMap(target, propertyKey) {
const targetMetadata = Metadata.get(target) || new Map();
Metadata.set(target, targetMetadata);
const metadataMap = targetMetadata.get(propertyKey) || new Map();
targetMetadata.set(propertyKey, metadataMap);
return metadataMap;
}
function ordinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey) {
if (propertyKey && !["string", "symbol"].includes(typeof propertyKey)) {
throw new TypeError();
}
(getMetadataMap(target, propertyKey) || createMetadataMap(target, propertyKey)).set(metadataKey, metadataValue);
}
function ordinaryGetMetadata(metadataKey, target, propertyKey) {
return ordinaryGetOwnMetadata(metadataKey, target, propertyKey) ? ordinaryGetOwnMetadata(metadataKey, target, propertyKey) : Object.getPrototypeOf(target) ? ordinaryGetMetadata(metadataKey, Object.getPrototypeOf(target), propertyKey) : void 0;
}
function metadata(metadataKey, metadataValue) {
return function decorator(target, propertyKey) {
ordinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
};
}
function getMetadata(metadataKey, target, propertyKey) {
return ordinaryGetMetadata(metadataKey, target, propertyKey);
}
function getOwnMetadata(metadataKey, target, propertyKey) {
return ordinaryGetOwnMetadata(metadataKey, target, propertyKey);
}
function hasOwnMetadata(metadataKey, target, propertyKey) {
return !!ordinaryGetOwnMetadata(metadataKey, target, propertyKey);
}
function hasMetadata(metadataKey, target, propertyKey) {
return !!ordinaryGetMetadata(metadataKey, target, propertyKey);
}
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
ordinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
const Reflection = {
decorate,
defineMetadata,
getMetadata,
getOwnMetadata,
hasMetadata,
hasOwnMetadata,
metadata
};
Object.assign(Reflect, Reflection);
const isFunction = (val) => typeof val === "function";
const isObject = (val) => val !== null && typeof val === "object";
const isPromise = (val) => {
return isObject(val) && isFunction(val.then) && isFunction(val.catch);
};
const isArray = (val) => {
if (typeof Array.isArray === "function") {
return Array.isArray(val);
} else {
return Object.prototype.toString.call(val) === "[object Array]";
}
};
const VUE_APP = new InjectionToken("APP_USE");
const vue_app = {};
const APP_INITIALIZER = new InjectionToken("APP_INITIALIZER");
const VUE_APP_INIT_STARTUP = new InjectionToken("VUE_APP_INITSTARTUP");
const InjectorKey = Symbol("vue-module-injector");
const ModuleProvidersMetadataKey = Symbol("__ModuleProvidersMetadataKey");
const ModuleImportsMetadataKey = Symbol("__ModuleImportsMetadataKey");
const ModuleDeclarationsMetadataKey = Symbol("__ModuleDeclarationsMetadataKey");
const ModuleBootstrapMetadataKey = Symbol("__ModuleBootstrapMetadataKey");
class VueModuleScanner {
constructor() {
this.providers = [];
this.declarations = [];
this.startupModules = [];
}
scanModule(module) {
this.scanImports(module);
this.scanProviders(module);
return {
providers: this.providers,
declarations: this.declarations,
startupModules: this.startupModules,
bootstrap: this.scanBootstrap(module)
};
}
scanBootstrap(module) {
return Reflect.getOwnMetadata(ModuleBootstrapMetadataKey, module) || null;
}
scanProviders(module) {
const providers = Reflect.getOwnMetadata(ModuleProvidersMetadataKey, module) || [];
this.providers = [...this.providers, ...providers];
}
scanImports(module) {
const imports = Reflect.getOwnMetadata(ModuleImportsMetadataKey, module) || [];
const moduleProviders = [];
imports.map((item) => {
if (item.vueModule) {
this.startupModules.push(item.vueModule);
}
if (item.providers) {
this.providers = [...this.providers, ...item.providers];
}
if (!item.vueModule && !item.providers) {
const itemModule = this.scanModule(item);
moduleProviders.concat(itemModule.providers);
moduleProviders.push(item);
}
});
this.providers = this.providers.concat(moduleProviders);
}
scanDeclarations(module) {
const declarations = Reflect.getOwnMetadata(ModuleDeclarationsMetadataKey, module) || [];
this.declarations = declarations;
}
}
function bootstrapModule(Module, ParentModule) {
const scanner = new VueModuleScanner();
const {
providers,
startupModules
} = scanner.scanModule(Module);
const childRootInjector = ReflectiveInjector.resolveAndCreate([...providers || [], ...startupModules], ParentModule);
startupModules.map((sm) => {
childRootInjector.get(sm, null);
});
return childRootInjector;
}
class VueFactoryStatic {
create(module) {
return __async(this, null, function* () {
const scanner = new VueModuleScanner();
const app = createApp(scanner.scanBootstrap(module));
const RootInjector = ReflectiveInjector.resolveAndCreate([{
useValue: app,
provide: VUE_APP
}]);
const injector = bootstrapModule(module, RootInjector);
const startup = injector.get(VUE_APP_INIT_STARTUP, null);
if (isPromise(startup)) {
yield startup;
}
const initvue = injector.get(APP_INITIALIZER, null);
if (initvue) {
initvue(app);
}
app.provide(InjectorKey, injector);
return app;
});
}
}
const VueFactory = (module, useVue) => __async(this, null, function* () {
const vue = yield new VueFactoryStatic().create(module);
useVue && useVue(vue);
});
class SetModule {
static setModuleProviders(providers, target) {
Reflect.defineMetadata(ModuleProvidersMetadataKey, providers || [], target);
}
static setModuleImports(imports, target) {
Reflect.defineMetadata(ModuleImportsMetadataKey, imports || [], target);
}
static setModuleDeclarations(declarations, target) {
Reflect.defineMetadata(ModuleDeclarationsMetadataKey, declarations || [], target);
}
static setModuleBootstrap(bootstrap, target) {
Reflect.defineMetadata(ModuleBootstrapMetadataKey, bootstrap, target);
}
}
function VueModule(config) {
return function(target) {
SetModule.setModuleProviders(config.providers || [], target);
SetModule.setModuleImports(config.imports || [], target);
SetModule.setModuleBootstrap(config.bootstrap, target);
return Injectable()(target);
};
}
function _typeof(obj) {
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof(obj);
}
function boundMethod(target, key, descriptor) {
var fn = descriptor.value;
if (typeof fn !== "function") {
throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
}
var definingProperty = false;
return {
configurable: true,
get: function get() {
if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
return fn;
}
var boundFn = fn.bind(this);
definingProperty = true;
Object.defineProperty(this, key, {
configurable: true,
get: function get2() {
return boundFn;
},
set: function set(value) {
fn = value;
delete this[key];
}
});
definingProperty = false;
return boundFn;
},
set: function set(value) {
fn = value;
}
};
}
function boundClass(target) {
var keys;
if (typeof Reflect !== "undefined" && typeof Reflect.ownKeys === "function") {
keys = Reflect.ownKeys(target.prototype);
} else {
keys = Object.getOwnPropertyNames(target.prototype);
if (typeof Object.getOwnPropertySymbols === "function") {
keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
}
}
keys.forEach(function(key) {
if (key === "constructor") {
return;
}
var descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
if (typeof descriptor.value === "function") {
Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
}
});
return target;
}
function autobind() {
if (arguments.length === 1) {
return boundClass.apply(void 0, arguments);
}
return boundMethod.apply(void 0, arguments);
}
function Autobind() {
return autobind;
}
const ClassMetadataKey = Symbol("Vue-Class-Component");
const ProvidersMetadataKey = Symbol("Vue-Class-Component-Providers");
function Component(options) {
return function(target) {
if (!target.resolveComponent)
target.resolveComponent = resolveComponent;
Reflect.defineMetadata(ClassMetadataKey, __spreadValues({
name: options == null ? void 0 : options.name,
components: (options == null ? void 0 : options.components) || {},
inheritAttrs: (options == null ? void 0 : options.inheritAttrs) || true
}, options), target);
Reflect.defineMetadata(ProvidersMetadataKey, (options == null ? void 0 : options.providers) || [], target);
return Autobind()(Injectable()(target));
};
}
function resolveComponent(target) {
const parent = inject(InjectorKey, void 0);
const providers = Reflect.getOwnMetadata(ProvidersMetadataKey, target);
let deps = providers || [];
if (!deps.includes(target))
deps.unshift(target);
const resolveProviders = ReflectiveInjector.resolve(deps);
const injector = ReflectiveInjector.fromResolvedProviders(resolveProviders, parent);
provide(InjectorKey, injector);
const compInstance = injector.get(target);
if (providers == null ? void 0 : providers.length)
resolveProviders.forEach((k) => injector.get(k.key.token));
return compInstance;
}
function getComponentOptions(target) {
const componentOptions = Reflect.getOwnMetadata(ClassMetadataKey, target);
if (!componentOptions) {
console.group(` %c error component ${target.name} `, "color: white; font-size: q4px; background: #f5222d; padding: 3px");
console.log(`${target.name} component need Component Decorators `);
console.groupEnd();
}
return componentOptions || {};
}
function useProps() {
const instance = getCurrentInstance();
return instance.props;
}
function useCtx() {
const instance = getCurrentInstance();
return instance.setupContext;
}
function getDeepOwnDescriptor(proto, key) {
if (!proto)
return null;
const desc = Reflect.getOwnPropertyDescriptor(proto, key);
if (desc)
return desc;
return getDeepOwnDescriptor(Reflect.getPrototypeOf(proto), key);
}
function getProtoMetadata(target, key, returnDesc = false) {
if (!target)
return [];
const proto = Reflect.getPrototypeOf(target);
if (!proto)
return [];
let res = Reflect.getMetadata(key, proto) || [];
if (returnDesc) {
res = res.map((k) => {
if (typeof k === "string") {
return {
key: k,
desc: getDeepOwnDescriptor(proto, k)
};
}
if (typeof k === "object") {
return {
key: k,
desc: getDeepOwnDescriptor(proto, k.key)
};
}
});
}
return res;
}
function getEmitsFromProps(defaultProps) {
const keys = Array.isArray(defaultProps) ? defaultProps : Object.keys(defaultProps);
const emits = [];
for (let key of keys) {
if (!/^on/.test(key))
continue;
key = key.slice(2).replace(/Once$/, "");
emits.push(key[0].toLowerCase() + key.slice(1));
}
return emits;
}
const $internalHooks = ["$props", "props", "context", "render", "resolveComponent", "__vccOpts__value", "__vccOpts", "constructor", "components", "beforeMount", "mounted", "beforeUpdate", "updated", "beforeUnmount", "unmounted", "errorCaptured", "renderTracked", "renderTriggered", "activated", "deactivated"];
function getSetupReturn(proto) {
const setupReturn = {};
const Prototype = Object.getPrototypeOf(proto);
Object.getOwnPropertyNames(Prototype).forEach((key) => {
if ($internalHooks.indexOf(key) > -1) {
return;
}
setupReturn[key] = Prototype[key];
});
const Proto = Object.getOwnPropertyDescriptors(proto);
Object.getOwnPropertyNames(Proto).forEach((key) => {
if ($internalHooks.indexOf(key) > -1) {
return;
}
setupReturn[key] = Proto[key].value;
});
return setupReturn;
}
const $LifecycleHook = {
beforeMount: onBeforeMount,
mounted: onMounted,
beforeUpdate: onBeforeUpdate,
updated: onUpdated,
beforeUnmount: onBeforeUnmount,
unmounted: onUnmounted,
errorCaptured: onErrorCaptured,
renderTracked: onRenderTracked,
renderTriggered: onRenderTriggered,
activated: onActivated,
deactivated: onDeactivated
};
function getLifecycle(proto) {
const Prototype = Object.getPrototypeOf(proto);
Object.getOwnPropertyNames(Prototype).forEach((key) => {
Object.getOwnPropertyNames($LifecycleHook).forEach((lifecycle) => {
if (key === lifecycle) {
return $LifecycleHook[lifecycle](() => proto[key]());
}
});
});
}
const PropMetadataKey = Symbol("__Component_Prop");
function Prop(propOptions) {
return function(target, key) {
let list = Reflect.getMetadata(PropMetadataKey, target.constructor) || [];
list = list.slice();
const hasItem = list.find((k) => k === key);
if (!hasItem)
list.push(__spreadValues({
key
}, propOptions));
Reflect.defineMetadata(PropMetadataKey, list, target.constructor);
Reflect.defineMetadata(PropMetadataKey, list, target);
};
}
function creatProps(targetThis) {
const list = Reflect.getMetadata(PropMetadataKey, targetThis) || [];
let creatPropsObj = {};
for (const item of list) {
creatPropsObj[item.key] = {
type: item.type || [String, Number, Object, Function, Boolean],
default: item.default
};
}
return creatPropsObj;
}
function handler$3(targetThis) {
const list = Reflect.getMetadata(PropMetadataKey, targetThis) || [];
if (!list || !list.length)
return;
for (const item of list) {
Object.defineProperty(targetThis, item.key, {
enumerable: true,
configurable: true,
get() {
return targetThis.props[item.key];
}
});
}
}
const PropHandler = {
key: "Prop",
handler: handler$3
};
const MetadataKey$2 = Symbol("Viewer");
function Viewer() {
return function(target, key) {
let list = Reflect.getMetadata(MetadataKey$2, target) || [];
list = list.slice();
const hasItem = list.find((k) => k === key);
if (!hasItem)
list.push(key);
Reflect.defineMetadata(MetadataKey$2, list, target);
};
}
function handler$2(targetThis, setupReturn) {
const list = getProtoMetadata(targetThis, MetadataKey$2);
if (!list || !list.length)
return;
if (!setupReturn) {
for (const item of list) {
const keyVal = ref(targetThis[item]);
Object.defineProperty(targetThis, item, {
enumerable: true,
configurable: true,
get() {
return keyVal.value;
},
set(v) {
keyVal.value = v;
}
});
}
} else {
for (const item of list) {
setupReturn[item] = ref(targetThis[item]);
Object.defineProperty(targetThis, item, {
enumerable: true,
configurable: true,
get() {
return setupReturn[item].value;
},
set(v) {
setupReturn[item].value = v;
}
});
}
}
}
const ViewerHandler = {
key: "Viewer",
handler: handler$2
};
const MetadataKey$1 = Symbol("Link");
function Link() {
return function(target, key) {
let list = Reflect.getMetadata(MetadataKey$1, target) || [];
list = list.slice();
const hasItem = list.find((k) => k === key);
if (!hasItem)
list.push(key);
Reflect.defineMetadata(MetadataKey$1, list, target);
};
}
function handler$1(targetThis, setupReturn) {
const list = getProtoMetadata(targetThis, MetadataKey$1);
if (!list || !list.length)
return;
for (const item of list) {
if (setupReturn) {
setupReturn[item] = ref();
Object.defineProperty(targetThis, item, {
enumerable: true,
configurable: true,
get() {
return setupReturn[item].value;
}
});
} else {
const instance = getCurrentInstance();
Object.defineProperty(targetThis, item, {
enumerable: true,
configurable: true,
get() {
return instance == null ? void 0 : instance.refs[item];
}
});
}
}
}
const LinkHandler = {
key: "Link",
handler: handler$1
};
const MetadataKey = Symbol("Computed");
function Computed() {
return function(target, key) {
let list = Reflect.getMetadata(MetadataKey, target) || [];
list = list.slice();
const hasItem = list.find((k) => k === key);
if (!hasItem)
list.push(key);
Reflect.defineMetadata(MetadataKey, list, target);
};
}
function handler(targetThis, setupReturn) {
const list = getProtoMetadata(targetThis, MetadataKey, true);
if (!list || !list.length)
return;
for (const item of list) {
if (setupReturn) {
const desc = item.desc;
setupReturn[item.key] = computed({
get: () => {
var _a2;
return (_a2 = desc.get) == null ? void 0 : _a2.call(targetThis);
},
set: (v) => {
var _a2;
return (_a2 = desc.set) == null ? void 0 : _a2.call(targetThis, v);
}
});
Object.defineProperty(targetThis, item.key, {
enumerable: desc == null ? void 0 : desc.enumerable,
configurable: true,
get() {
return setupReturn[item.key];
},
set(v) {
setupReturn[item.key].value = v;
}
});
} else {
const desc = item.desc;
const keyVal = computed({
get: () => {
var _a2;
return (_a2 = desc.get) == null ? void 0 : _a2.call(targetThis);
},
set: (v) => {
var _a2;
return (_a2 = desc.set) == null ? void 0 : _a2.call(targetThis, v);
}
});
Object.defineProperty(targetThis, item.key, {
enumerable: desc == null ? void 0 : desc.enumerable,
configurable: true,
get() {
return keyVal.value;
},
set(v) {
keyVal.value = v;
}
});
}
}
}
const ComputedHandler = {
key: "Computed",
handler
};
var __decorate$6 = globalThis && globalThis.__decorate || function(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;
};
var __metadata$5 = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var VueComponent_1;
let VueComponent = VueComponent_1 = class VueComponent2 {
constructor() {
this.setupReturn = {};
this.props = useProps();
this.context = useCtx();
this.context.expose(this);
if (this.render) {
VueComponent_1.handler.forEach((handler2) => handler2.handler(this));
} else {
this.setupReturn = getSetupReturn(this);
VueComponent_1.handler.forEach((handler2) => handler2.handler(this, this.setupReturn));
}
}
static get __vccOpts() {
if (this.__vccOpts__value)
return this.__vccOpts__value;
const CompConstructor = this;
const componentOptions = getComponentOptions(CompConstructor);
return this.__vccOpts__value = __spreadProps(__spreadValues(__spreadValues({}, CompConstructor), componentOptions), {
directives: CompConstructor.directives,
emits: (CompConstructor.emits || []).concat(getEmitsFromProps(componentOptions.props || {})),
props: creatProps(CompConstructor),
setup: (props, ctx) => {
let instance;
let setupReturn;
if (CompConstructor.resolveComponent) {
instance = CompConstructor.resolveComponent(CompConstructor);
} else {
instance = new CompConstructor();
}
getLifecycle(instance);
if (instance.render) {
setupReturn = instance.render.bind(instance);
} else {
setupReturn = __spreadValues(__spreadValues({}, instance), instance.setupReturn);
}
return setupReturn;
}
});
}
get $props() {
return this.props;
}
};
VueComponent.handler = [ViewerHandler, PropHandler, LinkHandler, ComputedHandler];
VueComponent = VueComponent_1 = __decorate$6([Injectable(), __metadata$5("design:paramtypes", [])], VueComponent);
class VueService {
constructor() {
VueService.handler.forEach((handler2) => handler2.handler(this));
}
}
VueService.handler = [ViewerHandler, ComputedHandler];
const DIRECTIVE = new InjectionToken("DIRECTIVE");
var __decorate$5 = globalThis && globalThis.__decorate || function(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;
};
var __metadata$4 = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __param$4 = globalThis && globalThis.__param || function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
let StartupDirective = class StartupDirective2 {
constructor(vue, directive) {
this.vue = vue;
if (directive) {
if (isArray(directive)) {
directive.map((item) => {
vue.directive(item.name, item);
});
} else {
directive && vue.directive(directive.name, directive);
}
}
}
};
StartupDirective = __decorate$5([Injectable(), __param$4(0, Inject(forwardRef(() => VUE_APP))), __param$4(1, Optional()), __param$4(1, Inject(DIRECTIVE)), __metadata$4("design:paramtypes", [Object, Object])], StartupDirective);
class DirectiveModule {
static forRoot() {
return {
providers: [],
vueModule: StartupDirective
};
}
}
const ROUTER_CONFIG = new InjectionToken("router-config");
const ROUTER_GUARD = new InjectionToken("router-guard ");
const RouterChildKey = Symbol("RouterChild");
function ModuleEmptyComponent(moduleConfig) {
return class Empty {
constructor() {
}
static get __vccOpts() {
const CompConstructor = this;
if (this.__vccOpts__value)
return this.__vccOpts__value;
return this.__vccOpts__value = {
setup: () => {
const parent = inject(InjectorKey);
const module = moduleConfig;
module.providers.push(CompConstructor);
const childInject = parent.resolveAndCreateChild([...module.providers, ...module.startupModules]);
childInject.get(CompConstructor);
provide(InjectorKey, childInject);
return () => moduleConfig.bootstrap ? h(moduleConfig.bootstrap) : createVNode(RouterView, null, null);
}
};
}
};
}
function bindModule(module, component) {
const moduleScanner = new VueModuleScanner();
const moduleConfig = moduleScanner.scanModule(module);
let emptyComponent = ModuleEmptyComponent(moduleConfig);
return {
component: Injectable()(emptyComponent)
};
}
function scannerRouterChildren(module) {
const moduleScanner = new VueModuleScanner();
const moduleConfig = moduleScanner.scanModule(module);
let routerChild = [];
moduleConfig.providers.map((item) => {
const child = Reflect.getOwnMetadata(RouterChildKey, item);
if (child) {
routerChild = child;
}
});
return routerChild;
}
function scannerRoutes(routes) {
return routes.map((_a2) => {
var _b2 = _a2, {
loadChildren,
children,
component
} = _b2, route = __objRest(_b2, [
"loadChildren",
"children",
"component"
]);
const _route = __spreadValues({}, route);
_route.component = component;
if (loadChildren) {
const {
component: emptyComponent
} = bindModule(loadChildren);
_route.children = scannerRoutes(scannerRouterChildren(loadChildren));
_route.component = emptyComponent;
}
if (children) {
_route.children = scannerRoutes(children);
}
return _route;
});
}
var __decorate$4 = globalThis && globalThis.__decorate || function(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;
};
var __metadata$3 = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __param$3 = globalThis && globalThis.__param || function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
let CreateRouterGuard = class CreateRouterGuard2 {
constructor(_guard) {
this._guard = _guard;
}
register(router) {
if (isArray(this._guard)) {
this._guard.map((item) => {
item.beforeEach && router.beforeEach(item.beforeEach);
item.afterEach && router.afterEach(item.afterEach);
item.beforeResolve && router.beforeResolve(item.beforeResolve);
});
} else {
this._guard.beforeEach && router.beforeEach(this._guard.beforeEach);
this._guard.afterEach && router.afterEach(this._guard.afterEach);
this._guard.beforeResolve && router.beforeResolve(this._guard.beforeResolve);
}
}
};
CreateRouterGuard = __decorate$4([Injectable(), __param$3(0, Inject(forwardRef(() => ROUTER_GUARD))), __metadata$3("design:paramtypes", [Object])], CreateRouterGuard);
let EmptyRouterGuard = class EmptyRouterGuard2 {
};
EmptyRouterGuard = __decorate$4([Injectable()], EmptyRouterGuard);
var __decorate$3 = globalThis && globalThis.__decorate || function(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;
};
var __metadata$2 = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __param$2 = globalThis && globalThis.__param || function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
var _a$1;
let EvilVueRouter = class EvilVueRouter2 {
constructor(CreateRouterGuard3, vue, routerConfig) {
this.CreateRouterGuard = CreateRouterGuard3;
this.vue = vue;
this.routerConfig = routerConfig;
this.created();
}
created() {
if (this.routerConfig) {
const routes = __spreadProps(__spreadValues({}, this.routerConfig), {
routes: scannerRoutes(this.routerConfig.routes)
});
const appRouter = createRouter(routes);
this.CreateRouterGuard.register(appRouter);
this.vue.use(appRouter);
}
}
};
EvilVueRouter = __decorate$3([Injectable(), __param$2(1, Inject(forwardRef(() => VUE_APP))), __param$2(2, Inject(ROUTER_CONFIG)), __metadata$2("design:paramtypes", [typeof (_a$1 = typeof CreateRouterGuard !== "undefined" && CreateRouterGuard) === "function" ? _a$1 : Object, Object, Object])], EvilVueRouter);
function RouterChildDecorator(routes) {
return function(target) {
Reflect.defineMetadata(RouterChildKey, routes || [], target);
return target;
};
}
function RouterChild(routes) {
return RouterChildDecorator(routes)(class ChildClass {
});
}
var __decorate$2 = globalThis && globalThis.__decorate || function(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;
};
let RouterService = class RouterService2 {
constructor() {
this.router = useRouter();
}
};
RouterService = __decorate$2([Injectable()], RouterService);
let RouteService = class RouteService2 {
constructor() {
this.route = useRoute();
}
};
RouteService = __decorate$2([Injectable()], RouteService);
class VueEvilRouterModule {
static forRoot(config) {
return {
providers: [{
useClass: EmptyRouterGuard,
provide: ROUTER_GUARD
}, CreateRouterGuard, {
provide: ROUTER_CONFIG,
useValue: config
}, RouterService, RouteService],
vueModule: EvilVueRouter
};
}
static forChild({
routes
}) {
return RouterChild(routes);
}
}
const HTTP_CLIENT_CONFIG = new InjectionToken("HttpClientConfig");
const defaultConfig = {};
var __decorate$1 = globalThis && globalThis.__decorate || function(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;
};
var __metadata$1 = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __param$1 = globalThis && globalThis.__param || function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
const HTTP_INTERCEPTORS = new InjectionToken("HTTP_INTERCEPTORS");
const HTTP_INTERCEPTORS_LOGGER = new InjectionToken("HTTP_INTERCEPTORS_LOGGER");
let HttpInterceptorHandler = class HttpInterceptorHandler2 {
constructor(_interceptors) {
this._interceptors = _interceptors;
this._registeredInterceptors = [];
}
get registeredInterceptors() {
return this._registeredInterceptors;
}
register(httpClientInterceptors) {
const defaultError = (error) => console.error(error);
if (isArray(this._interceptors)) {
this._interceptors.forEach((interceptor) => {
if (interceptor.interceptRequest) {
this._registeredInterceptors.push(httpClientInterceptors.request.use(interceptor.interceptRequest, interceptor.interceptRequestError || defaultError));
}
if (interceptor.interceptResponse) {
this.registeredInterceptors.push(httpClientInterceptors.response.use(interceptor.interceptResponse, interceptor.interceptResponseError ? interceptor.interceptResponseError : defaultError));
}
});
} else {
if (this._interceptors.interceptRequest) {
httpClientInterceptors.request.use(this._interceptors.interceptRequest, this._interceptors.interceptRequestError ? this._interceptors.interceptRequestError : defaultError);
}
if (this._interceptors.interceptResponse) {
httpClientInterceptors.response.use(this._interceptors.interceptResponse, this._interceptors.interceptResponseError ? this._interceptors.interceptResponseError : defaultError);
}
}
}
};
HttpInterceptorHandler = __decorate$1([Injectable(), __param$1(0, Optional()), __param$1(0, Inject(forwardRef(() => HTTP_INTERCEPTORS))), __metadata$1("design:paramtypes", [Object])], HttpInterceptorHandler);
class NoopInterceptor {
interceptRequest(request) {
return request;
}
interceptResponse(response) {
return response;
}
}
let started = Date.now();
class Logger {
interceptRequest(config) {
started = Date.now();
return config;
}
interceptRequestError(error) {
console.group(` %c request error `, "color: white; font-size: q4px; background: #f5222d; padding: 3px");
console.log("%c params: ", "color: white; font-size: q4px; background: #FDE047; padding: 3px", error.config.data || error.config.params);
console.groupEnd();
}
interceptResponseError(config) {
const elapsed = Date.now() - started;
if (!config.config) {
console.group(` %c error `, "color: white; font-size: q4px; background: #f5222d; padding: 3px", ` ${elapsed} ms`);
console.groupEnd();
return;
}
console.group(` %c error ${config.config.method} /url:${config.config.url} `, "color: white; font-size: q4px; background: #f5222d; padding: 3px", ` ${elapsed} ms`);
console.log("%c params:", "color: white; font-size: q4px; background: #FDE047; padding: 3px", config.config.data || config.config.params);
console.log("%c response: ", "color: white; font-size: q4px; background: #FDE047; padding: 3px", config.data);
console.groupEnd();
return Promise.reject(config);
}
interceptResponse(config) {
const elapsed = Date.now() - started;
if (!config || !config.config) {
console.group(` %c error `, "color: white; font-size: q4px; background: #f5222d; padding: 3px", `${elapsed} ms`);
console.groupEnd();
return Promise.reject(config);
}
console.group(` %c success ${config.config.method}/url:${config.config.url} `, "color: white; font-size: q4px; background: #409EFF; padding: 3px", `${elapsed} ms`);
console.log("%c params: ", "color: white; font-size: q4px; background: #67C23A; padding: 3px", config.config.data || config.config.params);
console.log("%c response: ", "color: white; font-size: q4px; background: #67C23A; padding: 3px", config.data);
console.groupEnd();
return config;
}
}
var __decorate = globalThis && globalThis.__decorate || function(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;
};
var __metadata = globalThis && globalThis.__metadata || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __param = globalThis && globalThis.__param || function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
var _a, _b;
let HttpClient = class HttpClient2 {
constructor(interceptorHandler, logger, config) {
this.interceptorHandler = interceptorHandler;
this.logger = logger;
this.moduleService = true;
this.LoggerInterceptorRequest = null;
this.LoggerInterceptorResponse = null;
this.axiosInstance = axios.create(__spreadValues(__spreadValues({}, defaultConfig), config));
this.interceptorHandler.register(this.axiosInstance.interceptors);
}
showLog() {
this.LoggerInterceptorRequest = this.axiosInstance.interceptors.request.use(this.logger.interceptRequest, this.logger.interceptRequestError);
this.LoggerInterceptorResponse = this.axiosInstance.interceptors.response.use(this.logger.interceptResponse, this.logger.interceptResponseError);
}
hiddenLog() {
this.axiosInstance.interceptors.request.eject(this.LoggerInterceptorRequest);
this.axiosInstance.interceptors.request.eject(this.LoggerInterceptorResponse);
}
get defaults() {
return this.axiosInstance.defaults;
}
get interceptors() {
return this.axiosInstance.interceptors;
}
request(config) {
return this.axiosInstance.request(config);
}
get(url, config) {
return this.axiosInstance.get(url, config);
}
head(url, config) {
return this.axiosInstance.head(url, config);
}
post(url, data, config) {
return this.axiosInstance.post(url, data, config);
}
put(url, data, config) {
return this.axiosInstance.put(url, data, config);
}
patch(url, data, config) {
return this.axiosInstance.patch(url, data, config);
}
delete(url, config) {
return this.axiosInstance.delete(url, config);
}
};
HttpClient.defaults = axios.defaults;
HttpClient.interceptors = axios.interceptors;
HttpClient = __decorate([Injectable(), __param(1, Optional()), __param(1, Inject(HTTP_INTERCEPTORS_LOGGER)), __param(2, Optional()), __param(2, Inject(HTTP_CLIENT_CONFIG)), __metadata("design:paramtypes", [typeof (_a = typeof HttpInterceptorHandler !== "undefined" && HttpInterceptorHandler) === "function" ? _a : Object, typeof (_b = typeof Logger !== "undefined" && Logger) === "function" ? _b : Object, Object])], HttpClient);
class HttpClientModule {
static forRoot(config) {
return {
providers: [{
useClass: NoopInterceptor,
provide: HTTP_INTERCEPTORS,
multi: true
}, {
useClass: Logger,
provide: HTTP_INTERCEPTORS_LOGGER
}, HttpInterceptorHandler, {
provide: HTTP_CLIENT_CONFIG,
useValue: config
}],
vueModule: HttpClient
};
}
}
function registerHttpClientProviders(config) {
return [{
useClass: NoopInterceptor,
provide: HTTP_INTERCEPTORS
}, HttpInterceptorHandler, {
provide: HTTP_CLIENT_CONFIG,
useValue: config
}, HttpClient];
}
export { APP_INITIALIZER, Component, Computed, DIRECTIVE, DirectiveModule, HTTP_CLIENT_CONFIG, HTTP_INTERCEPTORS, HTTP_INTERCEPTORS_LOGGER, HttpClient, HttpClientModule, HttpInterceptorHandler, InjectorKey, Link, ModuleBootstrapMetadataKey, ModuleDeclarationsMetadataKey, ModuleImportsMetadataKey, ModuleProvidersMetadataKey, NoopInterceptor, Prop, ROUTER_CONFIG, ROUTER_GUARD, RouteService, RouterService, VUE_APP, VUE_APP_INIT_STARTUP, Viewer, VueComponent, VueEvilRouterModule, VueFactory, VueModule, VueService, bootstrapModule, defaultConfig, registerHttpClientProviders, vue_app };