From 50d5a672fa2b7fbf2ce7abb672bafd19da6dcf77 Mon Sep 17 00:00:00 2001 From: xinxinran0221010 Date: Sat, 7 Mar 2020 02:36:13 +0800 Subject: [PATCH] feat(bearcat-es6) add type definition for bearcat-es6 0.6.1 (#42825) * feat(bearcat-es6) add type definition for bearcat-es6 0.6.1 * fix(bearcat-es6) fix tslint rules * fix(bearcat-es6) fix tslint rules * fix(bearcat-es6) supplement some interface and fix some tslint bug * fix(bearcat-es6) fix some tslint bug * fix(bearcat-es6) fix some tslint bug * fix(bearcat-es6) fix some tslint bug * fix(bearcat-es6) fix some tslint bug * fix(bearcat-es6) fix some tslint bug * fix(bearcat-es6) fix some tslint error, and restore tslint rule to default --- types/bearcat-es6/bearcat-es6-tests.ts | 131 +++ types/bearcat-es6/index.d.ts | 1203 ++++++++++++++++++++++++ types/bearcat-es6/tsconfig.json | 23 + types/bearcat-es6/tslint.json | 1 + 4 files changed, 1358 insertions(+) create mode 100644 types/bearcat-es6/bearcat-es6-tests.ts create mode 100644 types/bearcat-es6/index.d.ts create mode 100644 types/bearcat-es6/tsconfig.json create mode 100644 types/bearcat-es6/tslint.json diff --git a/types/bearcat-es6/bearcat-es6-tests.ts b/types/bearcat-es6/bearcat-es6-tests.ts new file mode 100644 index 0000000000..19463c71a8 --- /dev/null +++ b/types/bearcat-es6/bearcat-es6-tests.ts @@ -0,0 +1,131 @@ +import * as bearcat from 'bearcat-es6'; + +const EF = () => {}; + +bearcat.createApp({}); // $ExpectType Bearcat +bearcat.start(() => { + bearcat.getBeanByMeta({}); // $ExpectType object | null + bearcat.getBeanByFunc(EF); // $ExpectType object | null + bearcat.use('beanId'); + bearcat.module(EF, null); + bearcat.define('testId', EF, null); + bearcat.require('testId'); + bearcat.getBean('testId'); + bearcat.getFunction('testId'); // $ExpectType ConstructorFunction | null + bearcat.getClass('testId'); // $ExpectType ConstructorFunction | null + bearcat.extend('testSubId', 'testId'); + bearcat.call('testId', null); + bearcat.getModel('testSubId'); + bearcat.getRoute('testId', 'controllerEntry'); + + const applicationContext: bearcat.ApplicationContext = bearcat.getApplicationContext(); // $ExpectType ApplicationContext + applicationContext.init(); + applicationContext.setStartupDate(Date.now()); + applicationContext.getStartupDate(); // $ExpectType number + applicationContext.getResource('/a/c/b'); // $ExpectType object + applicationContext.getConfigLocations(); // $ExpectType string[] + applicationContext.addBeanFactoryPostProcessor({postProcessBeanFactory: EF}); + applicationContext.getBeanFactoryProcessors(); // $ExpectType BeanPostProcessor[] + applicationContext.refresh(); + applicationContext.refresh(() => {}); + applicationContext.isActive(); + applicationContext.getBean('testId'); + applicationContext.getBeanByMeta({}); + applicationContext.getBeanByFunc(EF); + applicationContext.getModel('mId'); + applicationContext.getModelDefinition('mId'); + applicationContext.getBeanFunction('testId'); + applicationContext.extendBean('testId', ['testParentId']); + applicationContext.doExtendBean('testId', 'testParentId'); + applicationContext.module(EF, null); + applicationContext.define('testNewId', EF, null); + applicationContext.require('testNewId'); + applicationContext.use(['testId']); + applicationContext.async(['testId']); + applicationContext.containsBean('testId'); // $ExpectType boolean + applicationContext.isSingleton('testId'); // $ExpectType boolean + applicationContext.isPrototype('testId'); // $ExpectType boolean + applicationContext.containsBeanDefinition('testId'); // $ExpectType boolean + applicationContext.isRunning(); // $ExpectType boolean + applicationContext.hasBeanFactory(); // $ExpectType boolean + applicationContext.getBeanDefinition('testId'); + applicationContext.removeBeanDefinition('testNewId'); + applicationContext.setEnv('testing'); + applicationContext.getEnv(); // $ExpectType string + applicationContext.setConfigPath('./config'); + applicationContext.getConfigPath(); + applicationContext.setHotPath('./src'); + applicationContext.getHotPath(); + applicationContext.getBase(); + + const asyncScriptLoader: bearcat.AsyncScriptLoader = applicationContext.getAsyncScriptLoader(); // $ExpectType AsyncScriptLoader + asyncScriptLoader.getLoadBeans(); + asyncScriptLoader.load(['abc'], () => {}); + asyncScriptLoader.save('/a/b', {}); + asyncScriptLoader.module('mId', {}); + asyncScriptLoader.resolve('mId', ''); // $ExpectType string + asyncScriptLoader.resolveDeps({}); + asyncScriptLoader.getPathById('mId'); + asyncScriptLoader.get('/a/b', []); + asyncScriptLoader.setApplicationContext(applicationContext); + + const bootStrapLoader: bearcat.BootStrapLoader = applicationContext.getBootStrapLoader(); // $ExpectType BootStrapLoader + bootStrapLoader.load(['a']); + + const resourceLoader: bearcat.ResourceLoader = applicationContext.getResourceLoader(); // $ExpectType ResourceLoader + resourceLoader.addLoadPath('./'); + resourceLoader.getConfigLoader(); + resourceLoader.load('./a'); + + const beanFactory: bearcat.BeanFactory = applicationContext.getBeanFactory(); // $ExpectType BeanFactory + const beanFactorySame = bearcat.getBeanFactory(); // $ExpectType BeanFactory + if (beanFactory !== beanFactorySame) { + return; // should not run here! + } + + beanFactory.getBean('testId'); + beanFactory.getBeanProxy('testId'); + beanFactory.getModelProxy('mId'); + beanFactory.getConstraint('cId'); + beanFactory.setParentBean('testParentBean'); + beanFactory.registerBeans({}); + beanFactory.registerBean('testNewId', {}); + beanFactory.registerModel('testId', 'mNewId', {}); + beanFactory.registerConstraint('testId', 'cNewId', {}); + beanFactory.preInstantiateSingletons(); + beanFactory.addBeanPostProcessor({postProcessBeanFactory: EF}); + beanFactory.getBeanPostProcessors(); + beanFactory.isSingleton('testId'); + beanFactory.isPrototype('testId'); + beanFactory.containsBean('testId'); + beanFactory.getBeanFunction('testId'); + beanFactory.setBeanFunction('testId', EF); + beanFactory.removeFunction('testId'); + beanFactory.getInitCb('testId'); + beanFactory.setInitCb('testId', EF); + beanFactory.getBeanDefinition('testId'); + beanFactory.getBeanDefinitions(); + beanFactory.removeBeanDefinition('testId'); + beanFactory.containsBeanDefinition('testId'); + beanFactory.getAspects(); // $ExpectType object[] + beanFactory.getModelDefinition('mId'); + beanFactory.getModelDefinitions(); + beanFactory.getConstraintDefinition('cId'); + beanFactory.setTableModelMap('tId', {}); + beanFactory.getModelDefinitionByTable('tId'); + + const moduleFactory: bearcat.ModuleFactory = applicationContext.getModuleFactory(); + moduleFactory.define('mId', {}); + moduleFactory.require('mId'); + + beanFactory.destroyBean('testId', {}); + beanFactory.destroySingleton('testNewId'); + beanFactory.destroySingletons(); + beanFactory.destroyBeanFactory(); + applicationContext.closeBeanFactory(); + applicationContext.cancelRefresh(); + applicationContext.destroy(); + bearcat.stop(); +}); + +bearcat.async('test', () => {}); diff --git a/types/bearcat-es6/index.d.ts b/types/bearcat-es6/index.d.ts new file mode 100644 index 0000000000..d40728b380 --- /dev/null +++ b/types/bearcat-es6/index.d.ts @@ -0,0 +1,1203 @@ +// Type definitions for bearcat-es6 0.6 +// Project: https://github.com/ChrisPei/bearcat-es6 +// Definitions by: Xin Li +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 3.0 + +/// + +import { EventEmitter } from 'events'; + +declare namespace bearcat { + type CallbackFunc = () => void; + type ParamClassFunc = () => void; + type ConstructorFunction = (...params: any[]) => any; + interface BeanPostProcessor { + postProcessBeanFactory: CallbackFunc; + } + + interface Bearcat { + opts: object; + configLocations: string[]; + state: number; + startTime: number; + version: string; + applicationContext: ApplicationContext; + + /** + * Bearcat createApp constructor function. + * + * @param configLocations context path array + * @param opts + * @param opts.NODE_ENV setup env + * @param opts.BEARCAT_ENV setup env + * @param opts.NODE_CPATH setup config path + * @param opts.BEARCAT_CPATH setup config path + * @param opts.BEARCAT_HPATH setup hot reload path(s), usually it is the scan source directory(app by default) + * @param opts.BEARCAT_LOGGER setup 'off' to turn off bearcat logger configuration + * @param opts.BEARCAT_HOT setup 'on' to turn on bearcat hot code reload + * @param opts.BEARCAT_ANNOTATION setup 'off' to turn off bearcat $ based annotation + * @param opts.BEARCAT_GLOBAL setup bearcat to be global object + * @param opts.BEARCAT_FUNCTION_STRING setup bearcat to use func.toString for $ based annotation + * + * @return bearcat object + * @api public + */ + createApp(configLocations: string[], opts: object): Bearcat; + + createApp(opts: object): Bearcat; + + /** + * Bearcat start app. + * + * @param cb start callback function + * @api public + */ + start(cb?: CallbackFunc): void; + + /** + * Bearcat stop app. + * it will stop internal applicationContext, destroy all singletonBeans + * + * @api public + */ + stop(): void; + + /** + * Bearcat get beanFactory instance. + * + * @return beanFactory instance + * @api public + */ + getBeanFactory(): BeanFactory; + + /** + * Bearcat get applicationContext. + * + * @return applicationContext + * @api public + */ + getApplicationContext(): ApplicationContext; + + /** + * Bearcat get bean from IoC container through meta argument. + * + * @param meta meta object + * @api public + */ + getBeanByMeta(meta: object): object | null; + + /** + * Bearcat get bean from IoC container through $ annotation function. + * + * @param func $ annotation function + * @api public + */ + getBeanByFunc(func: ParamClassFunc): object | null; + + /** + * Bearcat add async loading beans, this just add beans needed to be loaded to bearcat. + * + * Examples: + * + * bearcat.use(['car']); + * bearcat.use('car'); + * + * @param ids async loading beans id + * @api public + */ + use(ids: string | string[]): void; + + /** + * Bearcat async loading beans. + * + * @param ids async loading beans id + * @param cb callback with loaded bean instances + * @api public + */ + async(ids: string | string[], cb?: CallbackFunc): void; + + /** + * Bearcat add module(bean) to IoC container through $ annotation function. + * + * @param func $ annotation function + * @param context context object + * @api public + */ + module(func: ParamClassFunc, context?: object | null): object | void; + + /** + * Bearcat define module(bean). + * + * @param id + * @param factory function + * @param context object + * @api public + */ + define(id: string, factory: ParamClassFunc, context: object | null): void; + + /** + * Bearcat add module(bean) to IoC container through $ annotation function. + * + * Examples: + * + * var Car = bearcat.require('car'); + * + * @param id + * @api public + */ + require(id: string): any; + + /** + * Bearcat get bean from IoC container through beanName or meta argument. + * + * @param beanName + * @return bean + * @api public + */ + getBean(beanName: string | object | ParamClassFunc): object | null; + + /** + * Bearcat get bean constructor function from IoC container through beanName. + * + * Examples: + * + * + * // through beanName + * var Car = bearcat.getFunction("car"); + * + * + * @param beanName + * @return bean constructor function + * @api public + */ + getFunction(beanName: string): ConstructorFunction | null; + + /** + * Bearcat get bean constructor function from IoC container through beanName, the same as bearcat.getFunction. + * + * Examples: + * + * + * // through beanName + * var Car = bearcat.getClass("car"); + * + * + * @param beanName + * @return bean constructor function + * @api public + */ + getClass(beanName: string): ConstructorFunction | null; + + /** + * Bearcat shim to enable function inherits. + * + * Examples: + * + * + * bearcat.extend("bus", "car"); + * + * + * @param beanName + * @param superBeanName or superBeanName array + * @api public + */ + extend(beanName: string, superBeanName: string | string[]): void; + + /** + * Bearcat call function used for inherits to call super constructor function. + * + * Examples: + * + * + * bearcat.call("car", this); + * + * + * @param beanName + * @param context + * @param args + * @api public + */ + call(beanName: string, context?: object | null, ...args: any[]): void; + + /** + * Bearcat get model from bearcat through modelId. + * + * Examples: + * + * + * // through modelId + * var carModel = bearcat.getModel("car"); + * + * + * @param modelId + * @return model + * @api public + */ + getModel(modelId: string): object; + + /** + * Bearcat convenient function for using in MVC route mapping. + * + * Examples: + * + * + * // express + * var app = express(); + * app.get('/', bearcat.getRoute('bearController', 'index')); + * + * + * @param beanName + * @param fnName routeName + * @api public + */ + getRoute(beanName: string, fnName: string): ConstructorFunction; + } + + interface ApplicationContext extends EventEmitter { + opts: object; + configLocations: string[]; + loadBeans: string[]; + active: boolean; + reloadMap: object; + beanFactory: BeanFactory; + startUpDate: number; + extendBeanMap: object; + extendedBeanMap: object; + extendBeanCurMap: object; + moduleFactory: ModuleFactory; + resourceLoader: ResourceLoader; + bootStrapLoader: BootStrapLoader; + asyncScriptLoader: AsyncScriptLoader; + cpath: string; + hpath: string; + env: string; + base: string; + beanFactoryPostProcessors: BeanPostProcessor[]; + + /** + * ApplicationContext init. + * + * @api public + */ + init(): void; + + /** + * ApplicationContext set container startUpDate. + * + * @param startUpDate + * @api public + */ + setStartupDate(startUpDate: number): void; + + /** + * ApplicationContext get container startUpDate. + * + * @return startUpDate + * @api public + */ + getStartupDate(): number; + + /** + * ApplicationContext get resourceLoader. + * + * @return resourceLoader + * @api public + */ + getResourceLoader(): ResourceLoader; + + /** + * ApplicationContext get asyncScriptLoader. + * + * @return asyncScriptLoader + * @api public + */ + getAsyncScriptLoader(): AsyncScriptLoader; + + /** + * ApplicationContext get bootStrapLoader. + * + * @return bootStrapLoader + * @api public + */ + getBootStrapLoader(): BootStrapLoader; + + /** + * ApplicationContext get metaObjects resource from contextPath. + * + * @param cpath contextPath + * @return metaObjects + * @api public + */ + getResource(cpath: string): object; + + /** + * ApplicationContext get contextPath locations. + * + * @return contextPath locations + * @api public + */ + getConfigLocations(): string[]; + + /** + * ApplicationContext add beanFactoryPostProcessor. + * + * @param beanFactoryPostProcessor + * @api public + */ + addBeanFactoryPostProcessor(beanFactoryPostProcessor: BeanPostProcessor): void; + + /** + * ApplicationContext get beanFactoryPostProcessors. + * + * @return beanFactoryPostProcessors + * @api public + */ + getBeanFactoryProcessors(): BeanPostProcessor[]; + + /** + * ApplicationContext do refresh actions. + * refresh beanFactory, preIntialize singleton Beans + * + * @param cb callback function + * @api public + */ + refresh(cb?: CallbackFunc): void; + + /** + * ApplicationContext cancel refresh. + * + * @api publish + */ + cancelRefresh(): void; + + /** + * ApplicationContext destroy. + * + * @api public + */ + destroy(): void; + + /** + * ApplicationContext check whether applicationContext is active or not. + * + * @api public + */ + isActive(): boolean; + + /** + * ApplicationContext getBean through beanName from applicationContext. + * + * @param beanName + * @return beanObject + * @api public + */ + getBean(beanName: string): object; + + /** + * ApplicationContext getBean through metaObject from applicationContext. + * + * @param meta metaObject + * @return beanObject + * @api public + */ + getBeanByMeta(meta: object): object; + + /** + * ApplicationContext getBean through $ annotation function from applicationContext. + * + * @param func $ annotation function + * @return beanObject + * @api public + */ + getBeanByFunc(func: ConstructorFunction): object; + + /** + * ApplicationContext getModel through modelId. + * + * @param modelId + * @return model + * @api public + */ + getModel(modelId: string): object; + + /** + * ApplicationContext getModelDefinition through modelId. + * + * @param modelId + * @return modelDefinition + * @api public + */ + getModelDefinition(modelId: string): object; + + /** + * ApplicationContext get bean contructor function. + * + * @param beanName + * @return bean constructor function + * @api public + */ + getBeanFunction(beanName: string): ConstructorFunction; + + /** + * ApplicationContext extend bean. + * + * @param beanName + * @param superBeanName or superBeanName array + * @api public + */ + extendBean(beanName: string, superBeanName: string | string[]): void; + + /** + * ApplicationContext do extend bean. + * + * @param beanName + * @param superBeanName + * @api public + */ + doExtendBean(beanName: string, superBeanName: string): void; + + /** + * ApplicationContext add module(bean) to IoC container through $ annotation function from applicationContext. + * + * @param func $ annotation function + * @param context + * @api public + */ + module(func: ConstructorFunction, context?: object | null): void; + + /** + * ApplicationContext service locator pattern define module. + * + * @param id + * @param factory factory function + * @param context context object + * @api public + */ + define(id: string, factory: ConstructorFunction, context?: object | null): void; + + /** + * ApplicationContext service locator pattern define module. + * + * @param id + * @api public + */ + require(id: string): any; + + /** + * ApplicationContext add startup loaded bean ids. + * + * @param ids loaded bean ids + * @api public + */ + use(ids: string[]): void; + + /** + * ApplicationContext async load bean with bean ids. + * + * @param ids bean ids + * @param cb callback function + * @api public + */ + async(ids: string[], cb?: CallbackFunc): void; + + /** + * ApplicationContext check ApplicationContext contains bean or not. + * + * @param beanName + * @return a boolean value that contains bean or not + * @api public + */ + containsBean(beanName: string): boolean; + + /** + * ApplicationContext check bean is a singleton or not. + * + * @param beanName + * @return a boolean value that is a singleton or not + * @api public + */ + isSingleton(beanName: string): boolean; + + /** + * ApplicationContext check bean is a prototype or not. + * + * @param beanName + * @return a boolean value that is a prototype or not + * @api public + */ + isPrototype(beanName: string): boolean; + + /** + * ApplicationContext check ApplicationContext contains beanName beanDefinition or not. + * + * @param beanName + * @return a boolean value that contains beanName beanDefinition or not + * @api public + */ + containsBeanDefinition(beanName: string): boolean; + + /** + * ApplicationContext check whether applicationContext is running or not. + * + * @return true|false + * @api public + */ + isRunning(): boolean; + + /** + * ApplicationContext close beanFactory. + * + * @api public + */ + closeBeanFactory(): void; + + /** + * ApplicationContext check whether applicationContext has beanFactory or not. + * + * @return true|false + * @api public + */ + hasBeanFactory(): boolean; + + /** + * ApplicationContext getBeanFactory. + * + * @return beanFactory + * @api public + */ + getBeanFactory(): BeanFactory; + + /** + * ApplicationContext getModuleFactory. + * + * @return moduleFactory + * @api public + */ + getModuleFactory(): ModuleFactory; + + /** + * ApplicationContext get beanDefinition. + * + * @param beanName + * @return beanDefinition + * @api public + */ + getBeanDefinition(beanName: string): object; + + /** + * ApplicationContext remove beanDefinition from ApplicationContext. + * + * @param beanName + * @api public + */ + removeBeanDefinition(beanName: string): void; + + /** + * ApplicationContext set env. + * + * @param env + * @api public + */ + setEnv(env: string): void; + + /** + * ApplicationContext get env. + * + * @return env + * @api public + */ + getEnv(): string; + + /** + * ApplicationContext set config path. + * + * @param cpath config path + * @api public + */ + setConfigPath(cpath: string): void; + + /** + * ApplicationContext get config path. + * + * @return config path + * @api public + */ + getConfigPath(): string; + + /** + * ApplicationContext set hot reload path. + * + * @param hpath hot reload path + * @api public + */ + setHotPath(hpath: string): void; + + /** + * ApplicationContext get hot reload path. + * + * @return hpath hot reload path + * @api public + */ + getHotPath(): string; + + /** + * ApplicationContext get base path. + * + * @return base path + * @api public + */ + getBase(): string; + } + + interface BeanFactory { + aspects: object[]; + modelMap: object; + initCbMap: object; + beanCurMap: object; + constraints: object; + tableModelMap: object; + beanFunctions: object; + beanDefinitions: object; + beanPostProcessors: BeanPostProcessor[]; + singletonBeanFactory: SingletonBeanFactory; + + /** + * BeanFactory get bean instance through BeanFactory IoC container. + * + * @param beanName + * @return bean object + * @api public + */ + getBean(beanName: string): object; + + /** + * BeanFactory get bean proxy through BeanFactory IoC container for lazy init bean. + * when invoke bean proxy, proxy will invoke getBean to get the target bean + * + * @param beanName + * @return bean proxy object + * @api public + */ + getBeanProxy(beanName: string): object; + + /** + * BeanFactory get model through BeanFactory IoC container. + * + * @param modelId + * @return model proxy object + * @api public + */ + getModelProxy(modelId: string): object; + + /** + * BeanFactory get constraint through BeanFactory IoC container. + * + * @param cid + * @return constraint bean object + * @api public + */ + getConstraint(cid: string): object; + + /** + * BeanFactory set parent bean. + * + * @param beanName + * @return beanDefinition + * @api public + */ + setParentBean(beanName: string): object; + + /** + * BeanFactory register beans through metaObjects into BeanFactory. + * + * @param metaObjects + * @api public + */ + registerBeans(metaObjects: object): void; + + /** + * BeanFactory register bean through metaObject into BeanFactory. + * + * @param beanName + * @param metaObject + * @api public + */ + registerBean(beanName: string, metaObject: object): void; + + /** + * BeanFactory register model through metaObject into BeanFactory. + * + * @param beanName bean id + * @param modelId model id + * @param metaObject + * @api public + */ + registerModel(beanName: string, modelId: string, metaObject: object): void; + + /** + * BeanFactory register constraint through metaObject into BeanFactory. + * + * @param beanName bean id + * @param cid constraint id + * @param metaObject + * @api public + */ + registerConstraint(beanName: string, cid: string, metaObject: object): void; + + /** + * BeanFactory instantiating singletion beans in advance. + * + * @param cb callback function + * @api public + */ + preInstantiateSingletons(cb?: CallbackFunc): void; + + /** + * BeanFactory add beanPostProcessor to BeanFactory. + * @param beanPostProcessor + * @api public + */ + addBeanPostProcessor(beanPostProcessor: BeanPostProcessor): void; + + /** + * BeanFactory get beanPostProcessors. + * @return beanPostProcessors + * @api public + */ + getBeanPostProcessors(): BeanPostProcessor[]; + + /** + * BeanFactory destroy singletons. + * + * @api public + */ + destroySingletons(): void; + + /** + * BeanFactory destroy BeanFactory. + * + * @api public + */ + destroyBeanFactory(): void; + + /** + * BeanFactory destroy singleton. + * + * @param beanName + * @api public + */ + destroySingleton(beanName: string): void; + + /** + * BeanFactory destroy bean. + * + * @param beanName + * @param beanObject + * @api public + */ + destroyBean(beanName: string, beanObject: object): void; + + /** + * BeanFactory check bean is a singleton or not. + * + * @param beanName + * @return true | false + * @api public + */ + isSingleton(beanName: string): boolean; + + /** + * BeanFactory check bean is a prototype or not. + * + * @param beanName + * @return true | false + * @api public + */ + isPrototype(beanName: string): boolean; + + /** + * BeanFactory check BeanFactory contains bean or not. + * + * @param beanName + * @return true | false + * @api public + */ + containsBean(beanName: string): boolean; + + /** + * BeanFactory get bean contructor function. + * + * @param beanName + * @return bean constructor function + * @api public + */ + getBeanFunction(beanName: string): ConstructorFunction; + + /** + * BeanFactory set bean contructor function. + * + * @param beanName + * @param func bean constructor function + * @api public + */ + setBeanFunction(beanName: string, func: ConstructorFunction): void; + + /** + * BeanFactory remove bean contructor function from BeanFactory. + * + * @param beanName + * @api public + */ + removeFunction(beanName: string): void; + + /** + * BeanFactory get init method. + * + * @param beanName + * @return bean init method + * @api public + */ + getInitCb(beanName: string): CallbackFunc; + + /** + * BeanFactory set init method. + * + * @param beanName + * @param initCb bean init method + * @api public + */ + setInitCb(beanName: string, initCb: CallbackFunc): void; + + /** + * BeanFactory get beanDefinition. + * + * @param beanName + * @return beanDefinition + * @api public + */ + getBeanDefinition(beanName: string): object; + + /** + * BeanFactory get beanDefinitions. + * + * @return beanDefinitions + * @api public + */ + getBeanDefinitions(): object; + + /** + * BeanFactory remove beanDefinition from BeanFactory. + * + * @param beanName + * @api public + */ + removeBeanDefinition(beanName: string): void; + + /** + * BeanFactory check BeanFactory contains beanName beanDefinition or not. + * + * @param beanName + * @return true | false + * @api public + */ + containsBeanDefinition(beanName: string): boolean; + + /** + * BeanFactory get aspects. + * + * @return aspects + * @api public + */ + getAspects(): object[]; + + /** + * BeanFactory get modelDefinition. + * + * @param modelId + * @return modelDefinition + * @api public + */ + getModelDefinition(modelId: string): object; + + /** + * BeanFactory get modelDefinitions. + * + * @return modelDefinition map + * @api public + */ + getModelDefinitions(): object; + + /** + * BeanFactory get getConstraintDefinition. + * + * @param cid + * @return getConstraintDefinition + * @api public + */ + getConstraintDefinition(cid: string): object; + + /** + * BeanFactory set table model map. + * + * @param table name + * @param modelDefinition + * @api public + */ + setTableModelMap(table: string, modelDefinition: object): void; + + /** + * BeanFactory get modelDefinition by table. + * + * @param table name + * @return modelDefinition + * @api public + */ + getModelDefinitionByTable(table: string): object; + } + + interface SingletonBeanFactory { + beanFactory: BeanFactory; + singletonObjects: object; + + /** + * SingletonBeanFactory add singleton to SingletonBeanFactory. + * + * @param beanName + * @param beanObject + * @api public + */ + addSingleton(beanName: string, beanObject: object): void; + + /** + * SingletonBeanFactory check SingletonBeanFactory contains singleton or not. + * + * @param beanName + * @return true | false + * @api public + */ + containsSingleton(beanName: string): boolean; + + /** + * SingletonBeanFactory get singleton from SingletonBeanFactory. + * + * @param beanName + * @return singletonObject + * @api public + */ + getSingleton(beanName: string): object; + + /** + * SingletonBeanFactory get all singleton names from SingletonBeanFactory. + * + * @api public + */ + getSingletonNames(): string[]; + + /** + * SingletonBeanFactory remove singleton from SingletonBeanFactory. + * + * @param beanName + * @api public + */ + removeSingleton(beanName: string): void; + } + + interface ModuleFactory { + factoryMap: object; + moduleMap: object; + + define(id: string, factory: object): void; + + require(id: string): any; + } + + interface ResourceLoader { + loadPathMap: object; + loadPaths: string; + + /** + * ResourceLoader get config loader. + * + * @return config loader + * @api public + */ + getConfigLoader(): ConfigLoader; + + /** + * ResourceLoader add context load path. + * + * @param cpath context load path + * @api public + */ + addLoadPath(cpath: string): void; + + /** + * ResourceLoader load metaObjects from context path. + * + * @param cpath context load path + * @return metaObjects + * @api public + */ + load(cpath: string): object; + } + + interface ConfigLoader { + /** + * ConfigLoader get meta loader. + * + * @return meta loader + * @api public + */ + getMetaLoader(): MetaLoader; + + /** + * ConfigLoader get meta objects from context path. + * + * @param cpath context path + * @return meta objects + * @api public + */ + getResources(cpath: string): object; + + /** + * ConfigLoader get recursive scan paths and metaObjects in context.json. + * + * @param cpath context path + * @param scanPaths scan paths + * @param metaObjects + * @api public + */ + getRecursiveScanPath(cpath: string, scanPaths: string[], metaObjects: object): void; + } + + interface MetaLoader { + metaObjects: object; + + /** + * MetaLoader load metaObjects from meta path. + * + * @param mpath + * @return meta objects + * @api public + */ + load(mpath: string): object; + + /** + * MetaLoader set metaObject to beanName. + * + * @param beanName + * @param metaObject + * @api public + */ + setMetaObject(beanName: string, metaObject: object): void; + + /** + * MetaLoader get metaObjects. + * + * @return metaObjects + * @api public + */ + getMetaObjects(): object; + } + + interface AsyncScriptLoader { + cacheModules: object; + loaderDir: string; + applicationContext: ApplicationContext; + + /** + * AsyncScriptLoader get loaded beans list. + * + * @return loaded beans + * @api public + */ + getLoadBeans(): object[]; + + /** + * AsyncScriptLoader load beans asynchronously. + * + * @param ids loaded beans ids + * @param cb callback function + * @api public + */ + load(ids: string[], cb?: CallbackFunc): void; + + /** + * AsyncScriptLoader save load script with uri meta. + * + * @param uri + * @param meta + * @api public + */ + save(uri: string, meta: object): void; + + /** + * AsyncScriptLoader register script with id, meta. + * + * @param id + * @param beanMeta + * @api public + */ + module(id: string, beanMeta: object): void; + + /** + * AsyncScriptLoader resolve uri path with refUri. + * + * @param id + * @param refUri + * @return resolved path + * @api public + */ + resolve(id: string, refUri: string): string; + + /** + * AsyncScriptLoader resolve deps through bean meta. + * + * @param beanMeta + * @return resolved deps + * @api public + */ + resolveDeps(beanMeta: object): string[]; + + /** + * AsyncScriptLoader get bean path through bean id. + * + * @param id + * @return bean path + * @api public + */ + getPathById(id: string): string; + + /** + * AsyncScriptLoader get script from cache or new. + * + * @param uri + * @param deps id + * @return module + * @api public + */ + get(uri: string, deps: string[]): object; + + /** + * AsyncScriptLoader set applicationContext reference. + * + * @param applicationContext + * @api public + */ + setApplicationContext(applicationContext: ApplicationContext): void; + } + + interface BootStrapLoader { + /** + * BootStrapLoader load script files. + * + * @param idPaths + * @api public + */ + load(idPaths: string[]): void; + } +} + +declare var bearcat: bearcat.Bearcat; +export = bearcat; diff --git a/types/bearcat-es6/tsconfig.json b/types/bearcat-es6/tsconfig.json new file mode 100644 index 0000000000..c93fa9052c --- /dev/null +++ b/types/bearcat-es6/tsconfig.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.d.ts", + "bearcat-es6-tests.ts" + ] +} diff --git a/types/bearcat-es6/tslint.json b/types/bearcat-es6/tslint.json new file mode 100644 index 0000000000..3db14f85ea --- /dev/null +++ b/types/bearcat-es6/tslint.json @@ -0,0 +1 @@ +{ "extends": "dtslint/dt.json" }