overflow_backup_2018_0455/overflow_app
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ing

Browse Source
This commit is contained in:
crusader 2017-08-07 16:22:48 +09:00
parent 04fa16b60d
commit 05f949fd3a
113 changed files with 65 additions and 2533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,3 +1,4 @@
.DS_Store
.idea/ .idea/
node_modules/ node_modules/
dist/ dist/
@ -6,4 +7,4 @@ dist/
.idea .idea
yarn.lock yarn.lock
.yarnclean .yarnclean
npm-debug.log npm-debug.log

31
src/ts/@loafer/application/Application.ts
View File

@ -1,31 +0,0 @@
import AnnotationConfigApplicationContext from '@loafer/context/annotation/AnnotationConfigApplicationContext';
import ApplicationStater from '@loafer/application/ApplicationStater';
class Application {
// private appContext: AppContext;
private appClass: Class<any>;
// private appInstance: ApplicationStater;
public constructor(clazz: Class<any>) {
this.appClass = clazz;
}
public run(): void {
let context: AnnotationConfigApplicationContext = new AnnotationConfigApplicationContext();
context.register(AppConfig.prototype);
context.refresh();
context.getPouch('entitlement');
}
public static run(clazz: Class<any>): void {
new Application(clazz).run();
}
}
export class AppConfig {
}
export default Application;

5
src/ts/@loafer/application/ApplicationStater.ts
View File

@ -1,5 +0,0 @@
export interface ApplicationStater {
run(): void;
}
export default ApplicationStater;

21
src/ts/@loafer/application/decorator/ApplicationConfiguration.ts
View File

@ -1,21 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import {
ConfigurationAnnotation,
} from '@loafer/context/decorator/Configuration';
export class ApplicationConfigurationAnnotation extends ConfigurationAnnotation {
public constructor(qualifier?: QualifierName) {
super(qualifier);
}
public onClassDecorator = <TFunction extends Function>(target: TFunction): TFunction | void => {
console.log('ApplicationConfiguration');
}
}
export const ApplicationConfiguration = Decorator.create(ApplicationConfigurationAnnotation);
export default ApplicationConfiguration;

18
src/ts/@loafer/context/ApplicationContext.ts
View File

@ -1,18 +0,0 @@
// import EnvironmentCapable from '@loafer/core/env/EnvironmentCapable';
// import PouchFactory from '@loafer/pouches/factory/PouchFactory';
// import DefaultPouchFactory from '@loafer/pouches/factory/implement/DefaultPouchFactory';
// import ListablePouchFactory from '@loafer/pouches/factory/ListablePouchFactory';
// import HierarchicalPouchFactory from '@loafer/pouches/factory/HierarchicalPouchFactory';
// import InjectCapablePouchFactory from '@loafer/pouches/factory/config/InjectCapablePouchFactory';
// export interface ApplicationContext extends EnvironmentCapable, ListablePouchFactory, HierarchicalPouchFactory {
// getId?(): Identity<T>;
// getApplicationName(): string;
// getDisplayName(): string;
// getParent?(): ApplicationContext;
// getInjectCapablePouchFactory(): InjectCapablePouchFactory;
// }
// export default ApplicationContext;

11
src/ts/@loafer/context/ConfigurableApplicationContext.ts
View File

@ -1,11 +0,0 @@
// import {
// Identity<T>,
// } from '@loafer/core/constants/types';
// import ConfigurableEnvironment from '@loafer/core/env/ConfigurableEnvironment';
// import ApplicationContext from '@loafer/context/ApplicationContext';
// import Lifecycle from '@loafer/context/Lifecycle';
// export interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle {
// }
// export default ConfigurableApplicationContext;

7
src/ts/@loafer/context/Lifecycle.ts
View File

@ -1,7 +0,0 @@
export interface Lifecycle {
start(): void;
stop(): void;
isRunning(): boolean;
}
export default Lifecycle;

110
src/ts/@loafer/context/annotation/AnnotatedPouchDefinitionReader.ts
View File

@ -1,110 +0,0 @@
import {
Assert,
} from '@loafer/core/util';
import {
Annotation,
} from '@loafer/core/annotation';
import {
PouchDefinitionRegistry,
} from '@loafer/pouches/factory/support';
import {
AnnotatedGenericPouchDefinition,
} from '@loafer/pouches/factory/annotation';
import GenericApplicationContext from '@loafer/context/support/GenericApplicationContext';
export class AnnotatedPouchDefinitionReader {
private readonly registry: PouchDefinitionRegistry;
private pouchNameGenerator: PouchNameGenerator = new AnnotationPouchNameGenerator();
private scopeMetadataResolver: ScopeMetadataResolver = new AnnotationScopeMetadataResolver();
private conditionEvaluator: ConditionEvaluator;
public constructor(registry: PouchDefinitionRegistry, environment?: Environment) {
if (undefined === environment) {
environment = this.getOrCreateEnvironment(registry);
}
Assert.notNull(registry, 'PouchDefinitionRegistry must not be null');
Assert.notNull(environment, 'Environment must not be null');
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
/**
* Register one or more annotated classes to be processed.
* <p>Calls to {@code register} are idempotent; adding the same
* annotated class more than once has no additional effect.
* @param annotatedClasses one or more annotated classes,
* e.g. {@link Configuration @Configuration} classes
*/
public register(...annotatedClasses: Class<any>[]): void {
annotatedClasses.forEach(annotatedClass => {
this.registerPouch(annotatedClass);
});
}
/**
* Register a pouch from the given pouch class, deriving its metadata from
* class-declared annotations.
* @param annotatedClass the class of the pouch
*/
public registerPouch(annotatedClass: Class<any>): void {
this.doRegisterPouch(annotatedClass, null, null, null);
}
/**
* Register a pouch from the given pouch class, deriving its metadata from
* class-declared annotations.
* @param annotatedClass the class of the pouch
* @param instanceSupplier a callback for creating an instance of the pouch
* (may be {@code null})
* @param name an explicit name for the pouch
* @param qualifiers specific qualifier annotations to consider, if any,
* in addition to qualifiers at the pouch class level
* @param definitionCustomizers one or more callbacks for customizing the
* factory's {@link PouchDefinition}, e.g. setting a lazy-init or primary flag
* @since 5.0
*/
public doRegisterPouch<T>(annotatedClass: Class<T>, instanceSupplier: Supplier<T>, name: PouchName,
qualifiers: Class<Annotation>[], ...definitionCustomizers: PouchDefinitionCustomizer[]): void {
let abd: AnnotatedGenericPouchDefinition = new AnnotatedGenericPouchDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
let scopeMetadata: ScopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
let pouchName: PouchName = (name != null ? name : this.pouchNameGenerator.generatePouchName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
qualifiers.forEach((qualifier, index) => {
if (Primary.class === qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class === qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
});
}
definitionCustomizers.forEach((customizer) => {
customizer.customize(abd);
});
let definitionHolder: PouchDefinitionHolder = new PouchDefinitionHolder(abd, pouchName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
PouchDefinitionReaderUtils.registerPouchDefinition(definitionHolder, this.registry);
}
}
export default AnnotatedPouchDefinitionReader;

17
src/ts/@loafer/context/annotation/AnnotationConfigApplicationContext.ts
View File

@ -1,17 +0,0 @@
import {
Assert,
} from '@loafer/core/util';
import GenericApplicationContext from '@loafer/context/support/GenericApplicationContext';
import AnnotatedPouchDefinitionReader from '@loafer/context/annotation/AnnotatedPouchDefinitionReader';
export class AnnotationConfigApplicationContext extends GenericApplicationContext {
private readonly reader: AnnotatedPouchDefinitionReader;
public register(...annotatedClasses: Class<any>[]): void {
Assert.notEmpty(annotatedClasses, 'At least one annotated class must be specified');
this.reader.register(annotatedClasses);
}
}
export default AnnotationConfigApplicationContext;

21
src/ts/@loafer/context/decorator/Configuration.ts
View File

@ -1,21 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import {
InjectableAnnotation,
} from '@loafer/pouches/decorator/Injectable';
export class ConfigurationAnnotation extends InjectableAnnotation {
public constructor(qualifier?: QualifierName) {
super(qualifier);
}
public onClassDecorator = <TFunction extends Function>(target: TFunction): TFunction | void => {
console.log('Configuration');
}
}
export const Configuration = Decorator.create(ConfigurationAnnotation);
export default Configuration;

29
src/ts/@loafer/context/decorator/Pouch.ts
View File

@ -1,29 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export interface PouchConfig {
qualifier?: QualifierName;
type?: Class<any>;
}
export class PouchAnnotation extends Annotation {
private readonly Qualifier: QualifierName;
private readonly Type: Class<any>;
public constructor(config: PouchConfig = {}) {
super();
this.Qualifier = config.qualifier;
this.Type = config.type;
}
public onMethodDecorator = <T>(target: Object, propertyKey: Identity<T>,
descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void => {
console.log('Pouch');
}
}
export const Pouch = Decorator.create(PouchAnnotation);
export default Pouch;

5
src/ts/@loafer/context/support/AbstractApplicationContext.ts
View File

@ -1,5 +0,0 @@
export abstract class AbstractApplicationContext {
}
export default AbstractApplicationContext;

10
src/ts/@loafer/context/support/GenericApplicationContext.ts
View File

@ -1,10 +0,0 @@
import AbstractApplicationContext from '@loafer/context/support/AbstractApplicationContext';
import PouchDefinitionRegistry from '@loafer/pouches/factory/support/PouchDefinitionRegistry';
export class GenericApplicationContext extends AbstractApplicationContext implements PouchDefinitionRegistry {
}
export default GenericApplicationContext;

8
src/ts/@loafer/core/AliasRegistry.ts
View File

@ -1,8 +0,0 @@
export interface AliasRegistry {
registerAlias(name: PouchName, alias: PouchName): void;
removeAlias(alias: PouchName): void;
isAlias(name: PouchName): boolean;
getAliases(name: PouchName): PouchName[];
}
export default AliasRegistry;

5
src/ts/@loafer/core/AttributeAccessor.ts
View File

@ -1,5 +0,0 @@
export interface AttributeAccessor {
}
export default AttributeAccessor;

8
src/ts/@loafer/core/AttributeAccessorSupport.ts
View File

@ -1,8 +0,0 @@
import {
AttributeAccessor,
} from '@loafer/core';
export abstract class AttributeAccessorSupport implements AttributeAccessor {
}
export default AttributeAccessorSupport;

10
src/ts/@loafer/core/MethodParameter.ts
View File

@ -1,10 +0,0 @@
import Executable from '@loafer/core/reflect/Executable';
import Parameter from '@loafer/core/reflect/Parameter';
import Method from '@loafer/core/reflect/Method';
import Constructor from '@loafer/core/reflect/Constructor';
import Annotation from '@loafer/core/annotation/Annotation';
export class MethodParameter {
}
export default MethodParameter;

11
src/ts/@loafer/core/NestedRuntimeException.ts
View File

@ -1,11 +0,0 @@
import {
RuntimeException,
} from '@loafer/core/lang';
export class NestedRuntimeException extends RuntimeException {
public constructor(message?: string) {
super(message);
}
}
export default NestedRuntimeException;

7
src/ts/@loafer/core/SimpleAliasRegistry.ts
View File

@ -1,7 +0,0 @@
import AliasRegistry from '@loafer/core/AliasRegistry';
export class SimpleAliasRegistry implements AliasRegistry {
}
export default SimpleAliasRegistry;

13
src/ts/@loafer/core/annotation/Annotation.ts
View File

@ -1,13 +0,0 @@
export interface Annotation {
onClassDecorator?: <TFunction extends Function>(target: TFunction) => TFunction | void;
onPropertyDecorator?: (target: Object, propertyKey: PropertyName) => void;
onMethodDecorator?: <T>(target: Object, propertyKey: PropertyName,
descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
onParameterDecorator?: (target: Object, propertyKey: PropertyName, parameterIndex: number) => void;
}
export abstract class Annotation {
}
export default Annotation;

1
src/ts/@loafer/core/annotation/index.ts
View File

@ -1 +0,0 @@
export * from './Annotation';

6
src/ts/@loafer/core/constants/decorator.ts
View File

@ -1,6 +0,0 @@
export enum DecoratorType {
CLASS,
PROPERTY,
PARAMETER,
METHOD,
}

9
src/ts/@loafer/core/constants/reflect.ts
View File

@ -1,9 +0,0 @@
// used to access design time types
export const DESIGN_TYPE = 'design:type';
// used to access design time parameter types
export const DESIGN_PARAMTYPES = 'design:paramtypes';
// used to access design time return type
export const DESIGN_RETURNTYPE = 'design:returntype';
// used to access design time return type
export const REFLECT_META = 'loafer:reflectmeta';

88
src/ts/@loafer/core/decorator/Decorator.ts
View File

@ -1,88 +0,0 @@
import * as ReflectConstants from '@loafer/core/constants/reflect';
import Reflection from '@loafer/core/reflect/Reflection';
import Clazz from '@loafer/core/reflect/Clazz';
import Annotation from '@loafer/core/annotation/Annotation';
import DecoratorType from './DecoratorType';
export class Decorator {
public static create = (AnnotationType: Class<Annotation>) => {
return (...handlerArgs: any[]) => {
let annotation: Annotation = new AnnotationType(...handlerArgs);
return (...decoratorArgs: any[]) => {
let decoratorType: DecoratorType = Decorator._detectDecoratorType(name, annotation, decoratorArgs);
let type = typeof decoratorArgs[0] === 'function' ? decoratorArgs[0].prototype : decoratorArgs[0];
let reflection: Reflection = Reflect.getMetadata(ReflectConstants.REFLECT_META, type);
if (undefined === reflection) {
reflection = new Reflection(type);
Reflect.defineMetadata(ReflectConstants.REFLECT_META, reflection, type);
}
let clazz: Clazz = reflection.getClass();
switch(decoratorType) {
case DecoratorType.CLASS:
reflection.addClassAnnotation(annotation);
return annotation.onClassDecorator.call(annotation, clazz, decoratorArgs[0]);
case DecoratorType.PROPERTY:
reflection.addPropertyAnnotation(annotation, decoratorArgs[1]);
return annotation.onPropertyDecorator.call(annotation, clazz, decoratorArgs[0], decoratorArgs[1]);
case DecoratorType.METHOD:
reflection.addMethodAnnotation(annotation, decoratorArgs[1]);
return annotation.onMethodDecorator.call(annotation, clazz, decoratorArgs[0], decoratorArgs[1], decoratorArgs[2]);
case DecoratorType.PARAMETER:
reflection.addParameterAnnotation(annotation, decoratorArgs[1], decoratorArgs[2]);
return annotation.onParameterDecorator.call(annotation, clazz, decoratorArgs[0], decoratorArgs[1], decoratorArgs[2]);
default:
}
};
};
}
public static get = (targetType: Class<any>) => {
let reflection: Reflection = Reflect.getMetadata(ReflectConstants.REFLECT_META, targetType);
if (undefined === reflection) {
return undefined;
}
return reflection.getClass();
}
private static _detectDecoratorType(name: string, annotation: any, args: any[]): DecoratorType {
let params = [];
for (let i = 0; i < args.length; i++) {
if (args[i]) {
params.push(args[i]);
}
}
const paramCount = params.length;
let decoratorType: DecoratorType;
if (1 === paramCount) {
if ('onClassDecorator' in annotation) {
throw new Error(`Cannot apply @${name} decorator on Class.`);
}
decoratorType = DecoratorType.CLASS;
} else if (2 === paramCount) {
if ('onPropertyDecorator' in annotation) {
throw new Error(`Cannot apply @${name} decorator on Property.`);
}
decoratorType = DecoratorType.PROPERTY;
} else if (3 === paramCount) {
if(typeof args[2] === 'number') {
if ('onParameterDecorator' in annotation) {
throw new Error(`Cannot apply @${name} decorator on Parameter.`);
}
decoratorType = DecoratorType.PARAMETER;
} else {
if ('onMethodDecorator' in annotation) {
throw new Error(`Cannot apply @${name} decorator on Method.`);
}
decoratorType = DecoratorType.METHOD;
}
} else {
throw new Error(`@${name} decorator is not valid here!`);
}
return decoratorType;
}
}

8
src/ts/@loafer/core/decorator/DecoratorType.ts
View File

@ -1,8 +0,0 @@
export enum DecoratorType {
CLASS = 'Clazz',
PROPERTY = 'Property',
METHOD = 'Method',
PARAMETER = 'Parameter',
}
export default DecoratorType;

2
src/ts/@loafer/core/decorator/index.ts
View File

@ -1,2 +0,0 @@
export * from './Decorator';
export * from './DecoratorType';

6
src/ts/@loafer/core/env/ConfigurableEnvironment.ts vendored
View File

@ -1,6 +0,0 @@
import Environment from '@loafer/core/env/Environment';
export interface ConfigurableEnvironment extends Environment {
}
export default Environment;

6
src/ts/@loafer/core/env/ConfigurablePropertyResolver.ts vendored
View File

@ -1,6 +0,0 @@
import PropertyResolver from '@loafer/core/env/PropertyResolver';
export interface ConfigurablePropertyResolver extends PropertyResolver {
}
export default ConfigurablePropertyResolver;

6
src/ts/@loafer/core/env/Environment.ts vendored
View File

@ -1,6 +0,0 @@
import PropertyResolver from '@loafer/core/env/PropertyResolver';
export interface Environment extends PropertyResolver {
}
export default Environment;

6
src/ts/@loafer/core/env/EnvironmentCapable.ts vendored
View File

@ -1,6 +0,0 @@
import Environment from '@loafer/core/env/Environment';
export interface EnvironmentCapable {
}
export default EnvironmentCapable;

4
src/ts/@loafer/core/env/PropertyResolver.ts vendored
View File

@ -1,4 +0,0 @@
export interface PropertyResolver {
}
export default PropertyResolver;

6
src/ts/@loafer/core/index.ts
View File

@ -1,6 +0,0 @@
export * from './AliasRegistry';
export * from './AttributeAccessor';
export * from './AttributeAccessorSupport';
export * from './NestedRuntimeException';
export * from './SimpleAliasRegistry';

11
src/ts/@loafer/core/lang/IllegalArgumentException.ts
View File

@ -1,11 +0,0 @@
import {
RuntimeException,
} from '@loafer/core/lang';
export class IllegalArgumentException extends RuntimeException {
public constructor(message?: string) {
super(message);
}
}
export default IllegalArgumentException;

11
src/ts/@loafer/core/lang/IllegalStateException.ts
View File

@ -1,11 +0,0 @@
import {
RuntimeException,
} from '@loafer/core/lang';
export class IllegalStateException extends RuntimeException {
public constructor(message?: string) {
super(message);
}
}
export default IllegalStateException;

7
src/ts/@loafer/core/lang/RuntimeException.ts
View File

@ -1,7 +0,0 @@
export class RuntimeException extends Error {
public constructor(message?: string) {
super(message);
}
}
export default RuntimeException;

3
src/ts/@loafer/core/lang/index.ts
View File

@ -1,3 +0,0 @@
export * from './IllegalArgumentException';
export * from './IllegalStateException';
export * from './RuntimeException';

29
src/ts/@loafer/core/reflect/AnnotatedElement.ts
View File

@ -1,29 +0,0 @@
export abstract class AnnotatedElement {
private _annotationMap: Map<Class<any>, any>;
protected constructor() {
this._annotationMap = new Map();
}
public getDeclaredAnnotation(type: Class<any>): any {
return this._annotationMap.get(type);
}
public getDeclaredAnnotations(): IterableIterator<any> {
return this._annotationMap.values();
}
public addAnnotation(annotation: any): void {
const type: Class<any> = Object.getPrototypeOf(annotation);
this._annotationMap.set(type, annotation);
}
public hasAnnotation(type: Class<any>): boolean {
return this._annotationMap.has(type);
}
// public abstract getAnnotation(type: Class<any>): any;
// public abstract getAnnotations(): IterableIterator<any>;
}
export default AnnotatedElement;

70
src/ts/@loafer/core/reflect/Clazz.ts
View File

@ -1,70 +0,0 @@
import AnnotatedElement from './AnnotatedElement';
import Constructor from './Constructor';
import Property from './Property';
import Method from './Method';
export class Clazz extends AnnotatedElement {
private _type: Class<any>;
private _name: PropertyName;
private _constructor: Constructor;
private _properties: Map<PropertyName, Property>;
private _methodes: Map<PropertyName, Method>;
public constructor(type: Class<any>, parameterTypes: Class<any>[]) {
super();
this._type = type;
this._name = this._type.constructor.name;
this._constructor = new Constructor(parameterTypes);
this._properties = new Map();
this._methodes = new Map();
}
public get Type(): Class<any> {
return this._type;
}
public get Name(): PropertyName {
return this._name;
}
public get Constructor(): Constructor {
return this._constructor;
}
public addProperty(propertyKey: PropertyName, type: Class<any>): Property {
if (this._properties.has(propertyKey)) {
throw new Error(`Property[${propertyKey}:${type.constructor.name}] on Clazz[${this._name}] is exist already`);
}
let proerty = new Property(type, propertyKey);
this._properties.set(propertyKey, proerty);
return proerty;
}
public getProperty(propertyKey: PropertyName): Property {
return this._properties.get(propertyKey);
}
public hasProperty(propertyKey: PropertyName): boolean {
return this._properties.has(propertyKey);
}
public addMethod(propertyKey: PropertyName, parameterTypes: Class<any>[], returnType: Class<any>): Method {
if (this._methodes.has(propertyKey)) {
throw new Error(`Method[${propertyKey}:${returnType.constructor.name}] on Clazz[${this._name}] is exist already`);
}
let method = new Method(propertyKey, parameterTypes, returnType);
this._methodes.set(propertyKey, method);
return method;
}
public getMethod(propertyKey: PropertyName): Method {
return this._methodes.get(propertyKey);
}
public hasMethod(propertyKey: PropertyName): boolean {
return this._methodes.has(propertyKey);
}
}
export default Clazz;

10
src/ts/@loafer/core/reflect/Constructor.ts
View File

@ -1,10 +0,0 @@
import Executable from '@loafer/core/reflect/Executable';
export class Constructor extends Executable {
public constructor(parameterTypes: Class<any>[]) {
super(parameterTypes);
}
}
export default Constructor;

26
src/ts/@loafer/core/reflect/Executable.ts
View File

@ -1,26 +0,0 @@
import AnnotatedElement from './AnnotatedElement';
import Parameter from '@loafer/core/reflect/Parameter';
export abstract class Executable extends AnnotatedElement {
protected _parameters: Parameter[];
public constructor(parameterTypes: Class<any>[]) {
super();
this._parameters = [];
parameterTypes.forEach((currentValue, index, array) => {
this._parameters.push(new Parameter(currentValue, index));
});
}
public get Parameters(): Parameter[] {
return this._parameters;
}
public getParameter(index: number): Parameter {
return this._parameters[index];
}
}
export default Executable;

27
src/ts/@loafer/core/reflect/Method.ts
View File

@ -1,27 +0,0 @@
import Executable from '@loafer/core/reflect/Executable';
export class Method extends Executable {
private _name: PropertyName;
private _returnType: Class<any>;
public constructor(name: PropertyName, parameterTypes: Class<any>[], returnType: Class<any>) {
super(parameterTypes);
this._name = name;
this._returnType = returnType;
}
public get Name(): PropertyName {
return this._name;
}
public get ReturnType(): Class<any> {
return this._returnType;
}
public set ReturnType(returnType: Class<any>) {
this._returnType = returnType;
}
}
export default Method;

25
src/ts/@loafer/core/reflect/Parameter.ts
View File

@ -1,25 +0,0 @@
import AnnotatedElement from './AnnotatedElement';
import Constructor from './Constructor';
export class Parameter extends AnnotatedElement {
private _type: Class<any>;
private _index: number;
public constructor(type: Class<any>, index: number) {
super();
this._type = type;
this._index = index;
}
public get Type(): Class<any> {
return this._type;
}
public get Index(): number {
return this._index;
}
}
export default Parameter;

24
src/ts/@loafer/core/reflect/Property.ts
View File

@ -1,24 +0,0 @@
import AnnotatedElement from './AnnotatedElement';
import Constructor from './Constructor';
export class Property extends AnnotatedElement {
private _type: Class<any>;
private _name: PropertyName;
public constructor(type: Class<any>, name: PropertyName) {
super();
this._type = type;
this._name = name;
}
public get Name(): PropertyName {
return this._name;
}
public get Type(): Class<any> {
return this._type;
}
}
export default Property;

101
src/ts/@loafer/core/reflect/Reflection.ts
View File

@ -1,101 +0,0 @@
import * as ReflectConstants from '@loafer/core/constants/reflect';
import AnnotatedElement from './AnnotatedElement';
import Clazz from './Clazz';
export class Reflection {
private _clazz: Clazz;
public constructor(type: Class<any>) {
let parameterTypes: any[] = Reflect.getMetadata(ReflectConstants.DESIGN_PARAMTYPES, type.constructor);
this._clazz = new Clazz(type, this.convertParamTypes(parameterTypes));
}
/**
* getClass
*/
public getClass(): Clazz {
return this._clazz;
}
public addClassAnnotation(annotation: any): void {
let parameterTypes: any[] = Reflect.getMetadata(ReflectConstants.DESIGN_PARAMTYPES, this._clazz.Type);
const {valid, name} = this.validateAnnotation(annotation, this._clazz);
if (!valid) {
throw new Error(`Cannot apply @${name} decorator multiple times on Class[${this._clazz.Name}].`);
}
this._clazz.addAnnotation(annotation);
}
public addPropertyAnnotation(annotation: any, propertyKey: PropertyName): void {
let propertyType: any = Reflect.getMetadata(ReflectConstants.DESIGN_TYPE, this._clazz.Type, propertyKey);
let property = this._clazz.getProperty(propertyKey);
if (undefined === property) {
property = this._clazz.addProperty(propertyKey, propertyType.prototype);
}
const {valid, name} = this.validateAnnotation(annotation, property);
if (!valid) {
throw new Error(`Cannot apply @${name} decorator multiple times on Property[${this._clazz.Name}:${propertyKey}].`);
}
property.addAnnotation(annotation);
}
public addMethodAnnotation(annotation: any, propertyKey: PropertyName): void {
let parameterTypes: any[] = Reflect.getMetadata(ReflectConstants.DESIGN_PARAMTYPES, this._clazz.Type, propertyKey);
let returnType: any = Reflect.getMetadata(ReflectConstants.DESIGN_RETURNTYPE, this._clazz.Type, propertyKey);
let method = this._clazz.getMethod(propertyKey);
if (undefined === method) {
method = this._clazz.addMethod(propertyKey, this.convertParamTypes(parameterTypes), returnType.prototype);
}
const {valid, name} = this.validateAnnotation(annotation, method);
if (!valid) {
throw new Error(`Cannot apply @${name} decorator multiple times on Method[${this._clazz.Name}:${propertyKey}].`);
}
method.addAnnotation(annotation);
}
public addParameterAnnotation(annotation: any, propertyKey: PropertyName, parameterIndex: number): void {
let parameterTypes: any[] = Reflect.getMetadata(ReflectConstants.DESIGN_PARAMTYPES, this._clazz.Type, propertyKey);
let returnType: any = Reflect.getMetadata(ReflectConstants.DESIGN_RETURNTYPE, this._clazz.Type, propertyKey);
let method = this._clazz.getMethod(propertyKey);
if (undefined === method) {
method = this._clazz.addMethod(propertyKey, this.convertParamTypes(parameterTypes), returnType.prototype);
}
let parameter = method.getParameter(parameterIndex);
const {valid, name} = this.validateAnnotation(annotation, parameter);
if (!valid) {
throw new Error(`Cannot apply @${name} decorator multiple times on Parameter[${this._clazz.Name}:${propertyKey}(${parameterIndex}})].`);
}
parameter.addAnnotation(annotation);
}
private validateAnnotation(annotation: any, element: AnnotatedElement): {valid: boolean, name: string} {
const annotationType: Class<any> = Object.getPrototypeOf(annotation);
const name: string = annotationType.constructor.name;
if (element.hasAnnotation(annotationType)) {
return {valid: false, name: name};
}
return {valid: true, name: name};
}
private convertParamTypes(parameterTypes: any[]): Class<any>[] {
let returnTypes: Class<any>[] = [];
parameterTypes.forEach((currentValue, index, array) => {
returnTypes.push(currentValue.prototype);
});
return returnTypes;
}
}
export default Reflection;

8
src/ts/@loafer/core/reflect/index.ts
View File

@ -1,8 +0,0 @@
export * from './AnnotatedElement';
export * from './Clazz';
export * from './Constructor';
export * from './Executable';
export * from './Method';
export * from './Parameter';
export * from './Property';
export * from './Reflection';

4
src/ts/@loafer/core/type/AnnotatedTypeMetadata.ts
View File

@ -1,4 +0,0 @@
export interface AnnotatedTypeMetadata {
}
export default AnnotatedTypeMetadata;

9
src/ts/@loafer/core/type/AnnotationMetadata.ts
View File

@ -1,9 +0,0 @@
import {
AnnotatedTypeMetadata,
ClassMetadata,
} from '@loafer/core/type';
export interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {
}
export default AnnotationMetadata;

4
src/ts/@loafer/core/type/ClassMetadata.ts
View File

@ -1,4 +0,0 @@
export interface ClassMetadata {
}
export default ClassMetadata;

25
src/ts/@loafer/core/type/StandardAnnotationMetadata.ts
View File

@ -1,25 +0,0 @@
import {
AnnotationMetadata,
StandardClassMetadata,
} from '@loafer/core/type';
export class StandardAnnotationMetadata extends StandardClassMetadata implements AnnotationMetadata {
/**
* Create a new {@link StandardAnnotationMetadata} wrapper for the given Class,
* providing the option to return any nested annotations or annotation arrays in the
* form of {@link org.springframework.core.annotation.AnnotationAttributes} instead
* of actual {@link Annotation} instances.
* @param introspectedClass the Class to introspect
* @param nestedAnnotationsAsMap return nested annotations and annotation arrays as
* {@link org.springframework.core.annotation.AnnotationAttributes} for compatibility
* with ASM-based {@link AnnotationMetadata} implementations
* @since 3.1.1
*/
public constructor(introspectedClass: Class<any>, nestedAnnotationsAsMap: boolean) {
super(introspectedClass);
this.annotations = introspectedClass.getAnnotations();
this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
}
}
export default StandardAnnotationMetadata;

8
src/ts/@loafer/core/type/StandardClassMetadata.ts
View File

@ -1,8 +0,0 @@
import {
ClassMetadata,
} from '@loafer/core/type';
export class StandardClassMetadata extends ClassMetadata {
}
export default StandardClassMetadata;

5
src/ts/@loafer/core/type/index.ts
View File

@ -1,5 +0,0 @@
export * from './AnnotatedTypeMetadata';
export * from './AnnotationMetadata';
export * from './ClassMetadata';
export * from './StandardAnnotationMetadata';
export * from './StandardClassMetadata';

128
src/ts/@loafer/core/util/Assert.ts
View File

@ -1,128 +0,0 @@
import {
IllegalStateException,
IllegalArgumentException,
} from '@loafer/core/lang';
import {
StringUtils,
} from '@loafer/core/util';
export abstract class Assert {
public static state(expression: boolean, message: string): void {
if (!expression) {
throw new IllegalStateException(message);
}
}
public static isTrue(expression: boolean, message: string): void {
if (!expression) {
throw new IllegalArgumentException(message);
}
}
public static isNull(object: any, message: string): void {
if (object !== null) {
throw new IllegalArgumentException(message);
}
}
public static notNull(object: any, message: string): void {
if (object == null) {
throw new IllegalArgumentException(message);
}
}
public static hasLength(text: string, message: string): void {
if (!StringUtils.hasLength(text)) {
throw new IllegalArgumentException(message);
}
}
public static hasText(text: string, message: string): void {
if (!StringUtils.hasText(text)) {
throw new IllegalArgumentException(message);
}
}
public static doesNotContain(textToSearch: string, substring: string, message: string): void {
if (StringUtils.hasLength(textToSearch) && StringUtils.hasLength(substring) &&
textToSearch.includes(substring)) {
throw new IllegalArgumentException(message);
}
}
public static notEmpty(collection: any[] | Map<any, any> | Set<any>, message: string): void {
if (undefined === collection || null === collection) {
throw new IllegalArgumentException(message);
}
let valid = true;
if (collection instanceof Array) {
let array: any[] = collection;
if (0 === collection.length) {
valid = false;
}
} else if (collection instanceof Map) {
let map: Map<any, any> = collection;
if (0 === map.size) {
valid = false;
}
} else if (collection instanceof Set) {
let set: Set<any> = collection;
if (0 === set.size) {
valid = false;
}
} else {
valid = false;
}
if (!valid) {
throw new IllegalArgumentException(message);
}
}
public static noNullElements(array: any[], message: string): void {
if (array !== null) {
array.forEach(element => {
if (element === null) {
throw new IllegalArgumentException(message);
}
});
}
}
public static isInstanceOf(type: Class<any>, obj: any, message: string = ''): void {
Assert.notNull(type, 'Type to check against must not be null');
if (!(obj instanceof type.constructor)) {
Assert.instanceCheckFailed(type, obj, message);
}
}
private static instanceCheckFailed(type: Class<any>, obj: any, message: string): void {
let className = (obj !== undefined && obj !== null ? Object.getPrototypeOf(obj).constructor.name : 'null');
let result = '';
let defaultMessage = true;
if (StringUtils.hasLength(message)) {
if (Assert.endsWithSeparator(message)) {
result = message + ' ';
} else {
result = Assert.messageWithTypeName(message, className);
defaultMessage = false;
}
}
if (defaultMessage) {
result = result + (`Object of class [${className}] must be an instance of ${type}`);
}
throw new IllegalArgumentException(result);
}
private static endsWithSeparator(message: string): boolean {
return (message.endsWith(':') || message.endsWith(';') || message.endsWith(',') || message.endsWith('.'));
}
private static messageWithTypeName(message: string, typeName: string): string {
return message + (message.endsWith(' ') ? '' : ': ') + typeName;
}
}
export default Assert;

64
src/ts/@loafer/core/util/ObjectUtils.ts
View File

@ -1,64 +0,0 @@
export abstract class ObjectUtils {
/**
* Determine if the given objects are equal, returning {@code true} if
* both are {@code null} or {@code false} if only one is {@code null}.
* <p>Compares arrays with {@code Arrays.equals}, performing an equality
* check based on the array elements rather than the array reference.
* @param o1 first Object to compare
* @param o2 second Object to compare
* @return whether the given objects are equal
* @see Object#equals(Object)
* @see java.util.Arrays#equals
*/
public static nullSafeEquals(o1: any, o2: any): boolean {
if (o1 === o2) {
return true;
}
if (o1 === undefined || o2 === undefined) {
return false;
}
if (o1 == null || o2 == null) {
return false;
}
if (Array.isArray(o1) && Array.isArray(o2)) {
return ObjectUtils.arrayEquals(o1, o2);
}
return false;
}
/**
* Compare the given arrays with {@code Arrays.equals}, performing an equality
* check based on the array elements rather than the array reference.
* @param o1 first array to compare
* @param o2 second array to compare
* @return whether the given objects are equal
* @see #nullSafeEquals(Object, Object)
* @see java.util.Arrays#equals
*/
private static arrayEquals(o1: any, o2: any): boolean {
if (!Array.isArray(o1) || !Array.isArray(o2)) {
return false;
}
if (o1 === o2) {
return true;
}
const arr1 = <Array<any>>o1;
const arr2 = <Array<any>>o2;
if (arr1.length !== arr2.length) {
return false;
}
arr1.forEach((value, index) => {
if (value !== arr2[index]) {
return false;
}
});
return true;
}
}
export default ObjectUtils;

223
src/ts/@loafer/core/util/StringUtils.ts
View File

@ -1,223 +0,0 @@
import {
IllegalStateException,
IllegalArgumentException,
} from '@loafer/core/lang';
export abstract class StringUtils {
private static readonly FOLDER_SEPARATOR: string = '/';
private static readonly WINDOWS_FOLDER_SEPARATOR: string = '\\';
private static readonly TOP_PATH: string = '..';
private static readonly CURRENT_PATH: string = '.';
private static readonly EXTENSION_SEPARATOR: string = '.';
public static isEmpty(str: any): boolean {
return (undefined === str || null === str || '' === str);
}
public static hasLength(str: string): boolean {
return (undefined !== str && null !== str && str.length > 0);
}
public static hasText(str: string): boolean {
if (!StringUtils.hasLength(str)) {
return false;
}
return str.trim() !== '';
}
public static containsWhitespace(str: string): boolean {
if (!StringUtils.hasLength(str)) {
return false;
}
return str.replace(/^\s+|\s+$/gm, '').length === 0;
}
public static trimWhitespace(str: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.trim();
}
public static trimAllWhitespace(str: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.replace(/\s/g, '');
}
public static trimLeadingWhitespace(str: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.replace(/^\s+/gm, '');
}
public static trimTrailingWhitespace(str: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.replace(/^\s+$/gm, '');
}
public static trimLeadingCharacter(str: string, leadingCharacter: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.replace(new RegExp('^[' + leadingCharacter + ']+'), '');
}
public static trimTrailingCharacter(str: string, trailingCharacter: string): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return str.replace(new RegExp('[' + trailingCharacter + ']+$'), '');
}
public static startsWithIgnoreCase(str: string, prefix: string): boolean {
if (undefined === str || null === str || undefined === prefix || null === prefix) {
return false;
}
if (str.startsWith(prefix)) {
return true;
}
if (str.length < prefix.length) {
return false;
}
const lcStr = str.substring(0, prefix.length).toLowerCase();
const lcPrefix = prefix.toLowerCase();
return lcStr === lcPrefix;
}
public static endsWithIgnoreCase(str: string, suffix: string): boolean {
if (str == null || suffix == null) {
return false;
}
if (str.endsWith(suffix)) {
return true;
}
if (str.length < suffix.length) {
return false;
}
const lcStr = str.substring(str.length - suffix.length).toLowerCase();
const lcSuffix = suffix.toLowerCase();
return lcStr === lcSuffix;
}
public static substringMatch(str: string, index: number, substring: string): boolean {
return str.includes(substring);
}
public static countOccurrencesOf(str: string, sub: string): number {
if (!StringUtils.hasLength(str) || !StringUtils.hasLength(sub)) {
return 0;
}
return (str.match(new RegExp(sub, 'gi')) || []).length;
}
public static replace(inString: string, oldPattern: string, newPattern: string): string {
if (!StringUtils.hasLength(inString) || !StringUtils.hasLength(oldPattern) || newPattern == null) {
return inString;
}
return inString.replace(new RegExp(oldPattern, 'g'), newPattern);
}
public static delete(inString: string, pattern: string): string {
return StringUtils.replace(inString, pattern, '');
}
public static deleteAny(inString: string, charsToDelete: string): string {
if (!StringUtils.hasLength(inString) || !StringUtils.hasLength(charsToDelete)) {
return inString;
}
return inString.replace(new RegExp('^[' + charsToDelete + ']+'), '');
}
public static quote(str: string): string {
return (str !== null ? '\'' + str + '\'' : null);
}
public static quoteIfString(obj: any): any {
return (typeof obj === 'string' ? StringUtils.quote(obj) : obj);
}
public static unqualify(qualifiedName: string, separator: string = '.'): string {
return qualifiedName.substring(qualifiedName.lastIndexOf(separator) + 1);
}
public static capitalize(str: string): string {
return StringUtils.changeFirstCharacterCase(str, true);
}
public static uncapitalize(str: string): string {
return StringUtils.changeFirstCharacterCase(str, false);
}
private static changeFirstCharacterCase(str: string, capitalize: boolean): string {
if (!StringUtils.hasLength(str)) {
return str;
}
return capitalize ? str.charAt(0).toUpperCase() + str.slice(1) : str.charAt(0).toLowerCase() + str.slice(1);
}
public static getFilename(path: string): string {
if (path === null) {
return null;
}
return path.split(StringUtils.WINDOWS_FOLDER_SEPARATOR).pop().split(StringUtils.FOLDER_SEPARATOR).pop();
}
public static getFilenameExtension(path: string): string {
if (path == null) {
return null;
}
return StringUtils.getFilename(path).split(StringUtils.EXTENSION_SEPARATOR).pop();
}
public static stripFilenameExtension(path: string): string {
if (path == null) {
return null;
}
return path.replace(new RegExp('[' + StringUtils.EXTENSION_SEPARATOR + StringUtils.getFilenameExtension(path) + ']+$'), '');
}
public static applyRelativePath(path: string, relativePath: string): string {
let separatorIndex = path.lastIndexOf(StringUtils.FOLDER_SEPARATOR);
if (separatorIndex !== -1) {
let newPath = path.substring(0, separatorIndex);
if (!relativePath.startsWith(StringUtils.FOLDER_SEPARATOR)) {
newPath += StringUtils.FOLDER_SEPARATOR;
}
return newPath + relativePath;
} else {
return relativePath;
}
}
}
export default StringUtils;

6
src/ts/@loafer/core/util/TypeUtils.ts
View File

@ -1,6 +0,0 @@
export abstract class TypeUtils {
}
export default TypeUtils;

5
src/ts/@loafer/core/util/index.ts
View File

@ -1,5 +0,0 @@
export * from './Assert';
export * from './ObjectUtils';
export * from './StringUtils';
export * from './TypeUtils';

7
src/ts/@loafer/globals.d.ts vendored
View File

@ -1,7 +0,0 @@
declare type Class<T> = {new(...args: any[]): T};
declare type Interface = Object;
declare type Identity<T> = T | symbol;
declare type PropertyName = Identity<string>;
declare type QualifierName = Identity<string>;
declare type PouchName = Identity<string>;
declare type ValueName = Identity<string>;

20
src/ts/@loafer/pouches/Mergeable.ts
View File

@ -1,20 +0,0 @@
export interface Mergeable {
/**
* Is merging enabled for this particular instance?
*/
isMergeEnabled(): boolean;
/**
* Merge the current value set with that of the supplied object.
* <p>The supplied object is considered the parent, and values in
* the callee's value set must override those of the supplied object.
* @param parent the object to merge with
* @return the result of the merge operation
* @throws IllegalArgumentException if the supplied parent is {@code null}
* @exception IllegalStateException if merging is not enabled for this instance
* (i.e. {@code mergeEnabled} equals {@code false}).
*/
merge(parent: any): any;
}
export default Mergeable;

14
src/ts/@loafer/pouches/PouchMetadataAttributeAccessor.ts
View File

@ -1,14 +0,0 @@
import {
AttributeAccessorSupport,
} from '@loafer/core';
import {
PouchMetadataElement,
} from '@loafer/pouches';
export class PouchMetadataAttributeAccessor extends AttributeAccessorSupport implements PouchMetadataElement {
}
export default PouchMetadataAttributeAccessor;

4
src/ts/@loafer/pouches/PouchMetadataElement.ts
View File

@ -1,4 +0,0 @@
export interface PouchMetadataElement {
}
export default PouchMetadataElement;

11
src/ts/@loafer/pouches/PouchesException.ts
View File

@ -1,11 +0,0 @@
import {
NestedRuntimeException,
} from '@loafer/core';
export class PouchesException extends NestedRuntimeException {
public constructor(message?: string) {
super(message);
}
}
export default PouchesException;

4
src/ts/@loafer/pouches/constants/types.ts
View File

@ -1,4 +0,0 @@
export enum PouchScope {
SINGLETON = 'Singleton',
TRANSIENT = 'Transient',
}

40
src/ts/@loafer/pouches/decorator/Inject.ts
View File

@ -1,40 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export interface InjectConfig {
qualifier?: QualifierName;
required?: boolean;
type?: Class<any>;
}
export class InjectAnnotation extends Annotation {
private readonly Qualifier: QualifierName;
private readonly Required: boolean;
private readonly Type: Class<any>;
public constructor(config: InjectConfig = {}) {
super();
this.Qualifier = config.qualifier;
this.Required = config.required;
this.Type = config.type;
}
public onPropertyDecorator = (target: Object, propertyKey: PropertyName): void => {
console.log('Inject');
}
public onMethodDecorator = <T>(target: Object, propertyKey: PropertyName,
descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void => {
console.log('Inject');
}
public onParameterDecorator = (target: Object, propertyKey: PropertyName, parameterIndex: number): void => {
console.log('Inject');
}
}
export const Inject = Decorator.create(InjectAnnotation);
export default Inject;

22
src/ts/@loafer/pouches/decorator/Injectable.ts
View File

@ -1,22 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export class InjectableAnnotation extends Annotation {
private readonly Qualifier: QualifierName;
public constructor(qualifier?: QualifierName) {
super();
this.Qualifier = qualifier;
}
public onClassDecorator = <TFunction extends Function>(target: TFunction): TFunction | void => {
console.log('Injectable');
}
}
export const Injectable = Decorator.create(InjectableAnnotation);
export default Injectable;

16
src/ts/@loafer/pouches/decorator/PostConstruct.ts
View File

@ -1,16 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export class PostConstructAnnotation extends Annotation {
public onMethodDecorator = <T>(target: Object, propertyKey: PropertyName,
descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void => {
console.log('PostConstruct');
}
}
export const PostConstruct = Decorator.create(PostConstructAnnotation);
export default PostConstruct;

16
src/ts/@loafer/pouches/decorator/PreDestroy.ts
View File

@ -1,16 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export class PreDestroyAnnotation extends Annotation {
public onMethodDecorator = <T>(target: Object, propertyKey: PropertyName,
descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void => {
console.log('PreDestroy');
}
}
export const PreDestroy = Decorator.create(PreDestroyAnnotation);
export default PreDestroy;

22
src/ts/@loafer/pouches/decorator/Scope.ts
View File

@ -1,22 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export class ScopeAnnotation extends Annotation {
private readonly Qualifier: QualifierName;
public constructor(qualifier?: QualifierName) {
super();
this.Qualifier = qualifier;
}
public onClassDecorator = <TFunction extends Function>(target: TFunction): TFunction | void => {
console.log('Scope');
}
}
export const Scope = Decorator.create(ScopeAnnotation);
export default Scope;

26
src/ts/@loafer/pouches/decorator/Value.ts
View File

@ -1,26 +0,0 @@
import {
Decorator,
} from '@loafer/core/decorator';
import Annotation from '@loafer/core/annotation/Annotation';
export class ValueAnnotation extends Annotation {
private readonly Value: ValueName;
public constructor(value: ValueName) {
super();
this.Value = value;
}
public onPropertyDecorator = (target: Object, propertyKey: PropertyName): void => {
console.log('Value');
}
public onParameterDecorator = (target: Object, propertyKey: PropertyName, parameterIndex: number): void => {
console.log('Value');
}
}
export const Value = Decorator.create(ValueAnnotation);
export default Value;

4
src/ts/@loafer/pouches/factory/DisposablePouch.ts
View File

@ -1,4 +0,0 @@
export interface DisposablePouch {
}
export default DisposablePouch;

4
src/ts/@loafer/pouches/factory/FactoryPouch.ts
View File

@ -1,4 +0,0 @@
export interface FactoryPouch<T> {
}
export default FactoryPouch;

6
src/ts/@loafer/pouches/factory/HierarchicalPouchFactory.ts
View File

@ -1,6 +0,0 @@
import PouchFactory from '@loafer/pouches/factory/PouchFactory';
export interface HierarchicalPouchFactory extends PouchFactory {
}
export default HierarchicalPouchFactory;

6
src/ts/@loafer/pouches/factory/ListablePouchFactory.ts
View File

@ -1,6 +0,0 @@
import PouchFactory from '@loafer/pouches/factory/PouchFactory';
export interface ListablePouchFactory extends PouchFactory {
}
export default ListablePouchFactory;

11
src/ts/@loafer/pouches/factory/NoSuchPouchDefinitionException.ts
View File

@ -1,11 +0,0 @@
import {
PouchesException,
} from '@loafer/pouches';
export class NoSuchPouchDefinitionException extends PouchesException {
public constructor(message?: string) {
super(message);
}
}
export default NoSuchPouchDefinitionException;

4
src/ts/@loafer/pouches/factory/ObjectFactory.ts
View File

@ -1,4 +0,0 @@
export interface ObjectFactory<T> {
}
export default ObjectFactory;

7
src/ts/@loafer/pouches/factory/PouchDefinitionStoreException.ts
View File

@ -1,7 +0,0 @@
export class PouchDefinitionStoreException extends Error {
public constructor(message?: string) {
super(message);
}
}
export default PouchDefinitionStoreException;

6
src/ts/@loafer/pouches/factory/PouchFactory.ts
View File

@ -1,6 +0,0 @@
export interface PouchFactory {
}
export default PouchFactory;

26
src/ts/@loafer/pouches/factory/annotation/AnnotatedGenericPouchDefinition.ts
View File

@ -1,26 +0,0 @@
import {
AnnotationMetadata,
} from '@loafer/core/type';
import {
GenericPouchDefinition,
} from '@loafer/pouches/factory/support';
import {
AnnotatedPouchDefinition,
} from '@loafer/pouches/factory/annotation';
export class AnnotatedGenericPouchDefinition extends GenericPouchDefinition implements AnnotatedPouchDefinition {
private readonly metadata: AnnotationMetadata;
public constructor(pouchClass: Class<any>) {
super();
this.PouchClass = pouchClass;
this.metadata = new StandardAnnotationMetadata(pouchClass, true);
}
}
export default AnnotatedGenericPouchDefinition;

11
src/ts/@loafer/pouches/factory/annotation/AnnotatedPouchDefinition.ts
View File

@ -1,11 +0,0 @@
import {
PouchDefinition,
} from '@loafer/pouches/factory/config';
export interface AnnotatedPouchDefinition extends PouchDefinition {
}
export default AnnotatedPouchDefinition;

2
src/ts/@loafer/pouches/factory/annotation/index.ts
View File

@ -1,2 +0,0 @@
export * from './AnnotatedPouchDefinition';
export * from './AnnotatedGenericPouchDefinition';

6
src/ts/@loafer/pouches/factory/config/ConfigurableListablePouchFactory.ts
View File

@ -1,6 +0,0 @@
import PouchFactory from '@loafer/pouches/factory/PouchFactory';
export interface ConfigurableListablePouchFactory {
}
export default ConfigurableListablePouchFactory;

12
src/ts/@loafer/pouches/factory/config/ConfigurablePouchFactory.ts
View File

@ -1,12 +0,0 @@
import PouchFactory from '@loafer/pouches/factory/PouchFactory';
import HierarchicalPouchFactory from '@loafer/pouches/factory/HierarchicalPouchFactory';
import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
import SingletonPouchRegistry from '@loafer/pouches/factory/config/SingletonPouchRegistry';
import PouchExpressionResolver from '@loafer/pouches/factory/config/PouchExpressionResolver';
export interface ConfigurablePouchFactory extends HierarchicalPouchFactory, SingletonPouchRegistry {
}
export default ConfigurablePouchFactory;

170
src/ts/@loafer/pouches/factory/config/ConstructorArgumentValues.ts
View File

@ -1,170 +0,0 @@
import {
Assert,
ObjectUtils,
TypeUtils,
} from '@loafer/core/util';
import {
Mergeable,
PouchMetadataElement,
} from '@loafer/pouches';
import {
HierarchicalPouchFactory,
PouchFactory,
} from '@loafer/pouches/factory';
import {
PouchDefinition,
PouchExpressionResolver,
SingletonPouchRegistry,
} from '@loafer/pouches/factory/config';
export class ConstructorArgumentValues {
private readonly indexedArgumentValues: Map<number, ValueHolder> = new Map();
private readonly genericArgumentValues: ValueHolder[] = [];
/**
* Deep copy constructor.
* @param original the ConstructorArgumentValues to copy
*/
public constructor(original?: ConstructorArgumentValues) {
//
}
}
/**
* Holder for a constructor argument value, with an optional type
* attribute indicating the target type of the actual constructor argument.
*/
export class ValueHolder implements PouchMetadataElement {
private value: any;
private type: string;
private name: string;
private source: any;
private converted: boolean = false;
private convertedValue: any;
/**
* Create a new ValueHolder for the given value, type and name.
* @param value the argument value
* @param type the type of the constructor argument
* @param name the name of the constructor argument
*/
public constructor( value: any, type?: string, name?: string) {
this.value = value;
this.type = type;
this.name = name;
}
/**
* Set the value for the constructor argument.
* @see PropertyPlaceholderConfigurer
*/
public set Value(value: any) {
this.value = value;
}
/**
* Return the value for the constructor argument.
*/
public get Value(): any {
return this.value;
}
/**
* Set the type of the constructor argument.
*/
public set Type(type: string) {
this.type = type;
}
/**
* Return the type of the constructor argument.
*/
public get Type(): string {
return this.type;
}
/**
* Set the name of the constructor argument.
*/
public set Name(name: string) {
this.name = name;
}
/**
* Return the name of the constructor argument.
*/
public get Name(): string {
return this.name;
}
/**
* Set the configuration source {@code Object} for this metadata element.
* <p>The exact type of the object will depend on the configuration mechanism used.
*/
public set Source(source: any) {
this.source = source;
}
public get Source(): any {
return this.source;
}
/**
* Return whether this holder contains a converted value already ({@code true}),
* or whether the value still needs to be converted ({@code false}).
*/
public isConverted(): boolean {
return this.converted;
}
/**
* Set the converted value of the constructor argument,
* after processed type conversion.
*/
public set ConvertedValue(value: any) {
this.converted = (value != null);
this.convertedValue = value;
}
/**
* Return the converted value of the constructor argument,
* after processed type conversion.
*/
public get ConvertedValue(): any {
return this.convertedValue;
}
/**
* Determine whether the content of this ValueHolder is equal
* to the content of the given other ValueHolder.
* <p>Note that ValueHolder does not implement {@code equals}
* directly, to allow for multiple ValueHolder instances with the
* same content to reside in the same Set.
*/
private contentEquals(other: ValueHolder): boolean {
return (this === other ||
(ObjectUtils.nullSafeEquals(this.value, other.value) && ObjectUtils.nullSafeEquals(this.type, other.type)));
}
/**
* Create a copy of this ValueHolder: that is, an independent
* ValueHolder instance with the same contents.
*/
public copy(): ValueHolder {
let copy: ValueHolder = new ValueHolder(this.value, this.type, this.name);
copy.Source = this.Source;
return copy;
}
}
export default ConstructorArgumentValues;

6
src/ts/@loafer/pouches/factory/config/InjectCapablePouchFactory.ts
View File

@ -1,6 +0,0 @@
import PouchFactory from '@loafer/pouches/factory/PouchFactory';
export interface InjectCapablePouchFactory extends PouchFactory {
}
export default InjectCapablePouchFactory;

124
src/ts/@loafer/pouches/factory/config/PouchDefinition.ts
View File

@ -1,124 +0,0 @@
import {
PouchScope,
} from '@loafer/pouches/constants/types';
export interface PouchDefinition {
/**
* The name of the parent definition of this pouch definition, if any.
*/
ParentName: PouchName;
/**
* The current pouch class name of this pouch definition.
* <p>Note that this does not have to be the actual class name used at runtime, in
* case of a child definition overriding/inheriting the class name from its parent.
* Also, this may just be the class that a factory method is called on, or it may
* even be empty in case of a factory pouch reference that a method is called on.
* Hence, do <i>not</i> consider this to be the definitive pouch type at runtime but
* rather only use it for parsing purposes at the individual pouch definition level.
* @see #getParentName()
* @see #getFactoryPouchName()
* @see #getFactoryMethodName()
*/
PouchClassName: string;
/**
* Override the target scope of this pouch, specifying a new scope name.
* @see #SCOPE_SINGLETON
* @see #SCOPE_PROTOTYPE
*/
Scope: string;
/**
* Whether this pouch should be lazily initialized.
* <p>If {@code false}, the pouch will get instantiated on startup by pouch
* factories that perform eager initialization of singletons.
*/
LazyInit: boolean;
/**
* The names of the pouchs that this pouch depends on being initialized.
* The pouch factory will guarantee that these pouchs get initialized first.
*/
DependsOn: PouchName[];
/**
* Whether this pouch is a candidate for getting autowired into some other pouch.
* <p>Note that this flag is designed to only affect type-based autowiring.
* It does not affect explicit references by name, which will get resolved even
* if the specified pouch is not marked as an autowire candidate. As a consequence,
* autowiring by name will nevertheless inject a pouch if the name matches.
*/
AutowireCandidate: boolean;
/**
* Whether this pouch is a primary autowire candidate.
* <p>If this value is {@code true} for exactly one pouch among multiple
* matching candidates, it will serve as a tie-breaker.
*/
Primary: boolean;
/**
* Specify the factory pouch to use, if any.
* This the name of the pouch to call the specified factory method on.
* @see #setFactoryMethodName
*/
FactoryPouchName: PouchName;
/**
* Specify a factory method, if any. This method will be invoked with
* constructor arguments, or with no arguments if none are specified.
* The method will be invoked on the specified factory pouch, if any,
* or otherwise as a static method on the local pouch class.
* @see #setFactoryPouchName
* @see #setPouchClassName
*/
FactoryMethodName: PropertyName;
/**
* Return the constructor argument values for this pouch.
* <p>The returned instance can be modified during pouch factory post-processing.
* @return the ConstructorArgumentValues object (never {@code null})
*/
getConstructorArgumentValues(): ConstructorArgumentValues;
/**
* Return the property values to be applied to a new instance of the pouch.
* <p>The returned instance can be modified during pouch factory post-processing.
* @return the MutablePropertyValues object (never {@code null})
*/
getPropertyValues(): MutablePropertyValues;
/**
* Return whether this a <b>Singleton</b>, with a single, shared instance
* returned on all calls.
* @see #SCOPE_SINGLETON
*/
isSingleton(): boolean;
/**
* Return whether this a <b>Prototype</b>, with an independent instance
* returned for each call.
* @see #SCOPE_PROTOTYPE
*/
isPrototype(): boolean;
/**
* Return whether this pouch is "abstract", that is, not meant to be instantiated.
*/
isAbstract(): boolean;
// Read-only attributes
/**
* Return a human-readable description of this pouch definition.
*/
getDescription(): string;
/**
* Return a description of the resource that this pouch definition
* came from (for the purpose of showing context in case of errors).
*/
getResourceDescription(): string;
/**
* Return the originating PouchDefinition, or {@code null} if none.
* Allows for retrieving the decorated pouch definition, if any.
* <p>Note that this method returns the immediate originator. Iterate through the
* originator chain to find the original PouchDefinition as defined by the user.
*/
getOriginatingPouchDefinition(): PouchDefinition;
}
export default PouchDefinition;

7
src/ts/@loafer/pouches/factory/config/PouchExpressionContext.ts
View File

@ -1,7 +0,0 @@
import ConfigurablePouchFactory from '@loafer/pouches/factory/config/ConfigurablePouchFactory';
import Scope from '@loafer/pouches/factory/config/Scope';
export class PouchExpressionContext {
}
export default PouchExpressionContext;

7
src/ts/@loafer/pouches/factory/config/PouchExpressionResolver.ts
View File

@ -1,7 +0,0 @@
import PouchExpressionContext from '@loafer/pouches/factory/config/PouchExpressionContext';
export interface PouchExpressionResolver {
}
export default PouchExpressionResolver;

7
src/ts/@loafer/pouches/factory/config/Scope.ts
View File

@ -1,7 +0,0 @@
import ObjectFactory from '@loafer/pouches/factory/ObjectFactory';
export interface Scope {
}
export default Scope;

4
src/ts/@loafer/pouches/factory/config/SingletonPouchRegistry.ts
View File

@ -1,4 +0,0 @@
export interface SingletonPouchRegistry {
}
export default SingletonPouchRegistry;

8
src/ts/@loafer/pouches/factory/config/index.ts
View File

@ -1,8 +0,0 @@
export * from './ConfigurableListablePouchFactory';
export * from './ConfigurablePouchFactory';
export * from './InjectCapablePouchFactory';
export * from './PouchDefinition';
export * from './PouchExpressionContext';
export * from './PouchExpressionResolver';
export * from './Scope';
export * from './SingletonPouchRegistry';

93
src/ts/@loafer/pouches/factory/implement/AbstractPouchFactory.ts
View File

@ -1,93 +0,0 @@
// import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
// import PouchDefinitionRegistry from '@loafer/pouches/factory/registry/PouchDefinitionRegistry';
// import DefaultSingletonPouchRegistry from '@loafer/pouches/factory/implement/DefaultSingletonPouchRegistry';
// abstract class AbstractPouchFactory extends DefaultSingletonPouchRegistry implements PouchDefinitionRegistry {
// protected pouchDefinitionMap: Map<Identity<T>, Map<Class<any>, PouchDefinition>>;
// public constructor() {
// super();
// this.pouchDefinitionMap = new Map();
// }
// public registerPouchDefinition(pouchDefinition: PouchDefinition): void {
// let clazz = pouchDefinition.Clazz;
// // let qualifier = validateQualifier(clazz, pouchDefinition.Qualifier);
// // if (this.hasPouchDefinition(qualifier, clazz)) {
// // throw new Error(`Pouch Definition[${clazz.constructor.name}:${qualifier}] is exist already`);
// // }
// // let map = this.pouchDefinitionMap.get(qualifier);
// // if (undefined === map) {
// // map = new Map();
// // this.pouchDefinitionMap.set(qualifier, map);
// // }
// // map.set(clazz, pouchDefinition);
// }
// public getPouchDefinition(qualifier: Identity<T>, clazz?: Class<any>): PouchDefinition {
// if (!this.pouchDefinitionMap.has(qualifier)) {
// return undefined;
// }
// let map = this.pouchDefinitionMap.get(qualifier);
// let count = map.size;
// let pouchDefinition: PouchDefinition;
// try {
// pouchDefinition = this._getDefinition(map, clazz);
// } catch(e) {
// console.log(`Type of Pouch Definition[${qualifier}] cannot be specified (count:${count})`);
// }
// return pouchDefinition;
// }
// public getPouchDefinitionByClass(clazz: Class<any>, qualifier?: Identity<T>): PouchDefinition {
// // const _qualifier = validateQualifier(clazz, qualifier);
// return this.getPouchDefinition(qualifier, clazz);
// }
// public hasPouchDefinition(qualifier: Identity<T>, clazz?: Class<any>): boolean {
// return undefined === this.getPouchDefinition(qualifier, clazz) ? false : true;
// }
// public hasPouchDefinitionByClass(clazz: Class<any>, qualifier?: Identity<T>): boolean {
// // const _qualifier = validateQualifier(clazz, qualifier);
// return this.hasPouchDefinition(qualifier, clazz);
// }
// public removePouchDefinition(qualifier: Identity<T>, clazz?: Class<any>): void {
// if (!this.hasPouchDefinition(qualifier, clazz)) {
// console.log(`Pouch Definition[${clazz.constructor.name}:${qualifier}] is not exist`);
// return;
// }
// this.pouchDefinitionMap.get(qualifier).delete(clazz);
// if (0 === this.pouchDefinitionMap.get(qualifier).size) {
// this.pouchDefinitionMap.delete(qualifier);
// }
// }
// public removePouchDefinitionByClass(clazz: Class<any>, qualifier?: Identity<T>): void {
// // const _qualifier = validateQualifier(clazz, qualifier);
// // this.removePouchDefinition(_qualifier, clazz);
// }
// private _getDefinition(map: Map<Class<any>, PouchDefinition>, clazz?: Class<any>): PouchDefinition {
// if (undefined !== clazz) {
// return map.get(clazz);
// }
// const count = map.size;
// if (1 < count) {
// throw new Error('Type of Pouch Definition cannot be specified.');
// }
// for (let value of Array.from(map.values())) {
// return value;
// }
// }
// }
// export default AbstractPouchFactory;

110
src/ts/@loafer/pouches/factory/implement/DefaultPouchFactory.ts
View File

@ -1,110 +0,0 @@
// import {
// PouchScope,
// } from '@loafer/pouches/constants/types';
// import PouchFactory from '@loafer/pouches/factory/PouchFactory';
// import AbstractPouchFactory from '@loafer/pouches/factory/implement/AbstractPouchFactory';
// import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
// import PouchDefinitionRegistry from '@loafer/pouches/factory/registry/PouchDefinitionRegistry';
// class DefaultPouchFactory extends AbstractPouchFactory implements PouchFactory, PouchDefinitionRegistry {
// public constructor() {
// super();
// }
// public getPouch(qualifier: Identity<T>, clazz: Class<any>, ...args: any[]): any {
// let pouchDefinition = this._getPouchDefinition(qualifier, clazz);
// if (undefined === pouchDefinition) {
// throw new Error(`This class[${clazz.constructor.name}:${qualifier}] is not pouch.`);
// }
// return this._getPouch(pouchDefinition, ...args);
// }
// public getPouchByClass(clazz: Class<any>, qualifier: Identity<T>, ...args: any[]): any {
// // let _qualifier = validateQualifier(clazz, qualifier);
// // let pouchDefinition = this._getPouchDefinition(_qualifier, clazz);
// // if (undefined === pouchDefinition) {
// // throw new Error(`This class[${clazz.constructor.name}:${qualifier}] is not pouch.`);
// // }
// // return this._getPouch(pouchDefinition, ...args);
// }
// private _getPouchDefinition(qualifier: Identity<T>, clazz: Class<any>): PouchDefinition {
// let pouchDefinition = this.getPouchDefinition(qualifier, clazz);
// if (undefined === pouchDefinition) {
// // pouchDefinition = this._getInjectableDefinition(clazz);
// if (undefined !== pouchDefinition) {
// this.registerPouchDefinition(pouchDefinition);
// }
// }
// return pouchDefinition;
// }
// private _getPouch(pouchDefinition: PouchDefinition, ...args: any[]): any {
// let instance;
// if (pouchDefinition.isSingleton()) {
// instance = this.getSingleton(pouchDefinition.Qualifier, pouchDefinition.Clazz);
// if (undefined !== instance) {
// return instance;
// }
// }
// instance = Object.create(pouchDefinition.Clazz);
// instance.constructor.apply(instance, ...args);
// this._injectDependency(instance, pouchDefinition.Clazz);
// }
// private _injectDependency(instance: any, clazz: Class<any>): void {
// if (clazz.constructor === Object) {
// return;
// }
// // let injectDefinition: InjectDefinition = this._getInjectDefinition(clazz);
// // if (undefined !== injectDefinition) {
// // let injectors: Map<Identity<T>, InjectItem> = injectDefinition.injectors;
// // let propertyDescriptor: PropertyDescriptor;
// // injectors.forEach((injectItem, key, map) => {
// // propertyDescriptor = Object.getOwnPropertyDescriptor(clazz, key);
// // switch (injectItem.decoratorType) {
// // case DecoratorType.PROPERTY:
// // this._injectDependencyProperty(instance, clazz, key, propertyDescriptor, injectItem.propertyConfig);
// // break;
// // case DecoratorType.PARAMETER:
// // this._injectDependencyParameter(instance, propertyDescriptor, injectItem.parameterConfigMap);
// // break;
// // default:
// // break;
// // }
// // });
// // }
// // this._injectDependency(instance, Object.getPrototypeOf(clazz));
// }
// // private _injectDependencyProperty(instance: any, clazz: Class<any>, propertyKey: Identity<T>,
// // propertyDescriptor: PropertyDescriptor, injectConfig: InjectConfig): void {
// // let pouch = this.getPouchByClass(injectConfig.clazz, injectConfig.qualifier);
// // if (injectConfig.required && undefined === instance) {
// // throw new Error(`Pouch which used by [${clazz.constructor.name}.${propertyKey}] is not exist in the context.`);
// // }
// // instance[propertyKey] = pouch;
// // }
// // private _injectDependencyParameter(target: object, propertyDescriptor: PropertyDescriptor,
// // parameterConfigs: Map<number, InjectConfig>): void {
// // console.log('');
// // }
// // private _getInjectableDefinition(clazz: Class<any>): InjectableDefinition {
// // return Reflect.getMetadata(POUCH_INJECTABLE_DEFINITION, clazz);
// // }
// // private _getInjectDefinition(clazz: Class<any>): InjectDefinition {
// // return Reflect.getMetadata(POUCH_INJECT_DEFINITION, clazz);
// // }
// }
// export default DefaultPouchFactory;

73
src/ts/@loafer/pouches/factory/implement/DefaultSingletonPouchRegistry.ts
View File

@ -1,73 +0,0 @@
import SingletonPouchRegistry from '@loafer/pouches/factory/config/SingletonPouchRegistry';
class DefaultSingletonPouchRegistry implements SingletonPouchRegistry {
protected singletonInstanceMap: Map<PouchName, Map<Class<any>, any>>;
protected constructor() {
this.singletonInstanceMap = new Map();
}
public registerSingleton(pouch: any, qualifier?: QualifierName): void {
let clazz: Class<any> = Object.getPrototypeOf(pouch);
// const _qualifier = validateQualifier(clazz, qualifier);
// if (this._hasSingleton(_qualifier, clazz)) {
// throw new Error(`Pouch Definition[${clazz.constructor.name}:${qualifier}] is exist already`);
// }
// let map = this.singletonInstanceMap.get(_qualifier);
// if (undefined === map) {
// map = new Map();
// this.singletonInstanceMap.set(_qualifier, map);
// }
// map.set(clazz, pouch);
}
public getSingleton(qualifier: QualifierName, clazz?: Class<any>): any {
return this._getSingleton(qualifier, clazz);
}
public getSingletonByClass(clazz: Class<any>, qualifier?: QualifierName): any {
// const _qualifier = validateQualifier(clazz, qualifier);
return this._getSingleton(qualifier, clazz);
}
public hasSingleton(qualifier: QualifierName, clazz?: Class<any>): boolean {
return this._hasSingleton(qualifier, clazz);
}
public hasSingletonByClass(clazz: Class<any>, qualifier?: QualifierName): boolean {
// const _qualifier = validateQualifier(clazz, qualifier);
return this._hasSingleton(qualifier, clazz);
}
private _getSingleton<T>(qualifier: QualifierName, clazz?: Class<any>): T {
if (!this.singletonInstanceMap.has(qualifier)) {
return undefined;
}
let map = this.singletonInstanceMap.get(qualifier);
let instance;
try {
instance = this._getInstance(map, clazz);
} catch(e) {
throw new Error(`Type of Pouch[${qualifier}] cannot be specified(count is ${map.size}).`);
}
return instance;
}
private _hasSingleton(qualifier: QualifierName, clazz?: Class<any>): boolean {
return undefined === this._getSingleton(qualifier, clazz) ? false : true;
}
private _getInstance(map: Map<Class<any>, any>, clazz?: Class<any>): any {
if (undefined !== clazz) {
return map.get(clazz);
}
const count = map.size;
if (1 < count) {
throw new Error(`Type of Pouch cannot be specified(count is ${count}).`);
}
for (let value of Array.from(map.values())) {
return value;
}
}
}
export default DefaultSingletonPouchRegistry;

7
src/ts/@loafer/pouches/factory/index.ts
View File

@ -1,7 +0,0 @@
export * from './FactoryPouch';
export * from './HierarchicalPouchFactory';
export * from './ListablePouchFactory';
export * from './NoSuchPouchDefinitionException';
export * from './PouchDefinitionStoreException';
export * from './PouchFactory';

7
src/ts/@loafer/pouches/factory/support/AbstractInjectCapablePouchFactory.ts
View File

@ -1,7 +0,0 @@
import AliasRegistry from '@loafer/core/AliasRegistry';
import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
export abstract class AbstractInjectCapablePouchFactory implements AliasRegistry {
}
export default AbstractInjectCapablePouchFactory;

12
src/ts/@loafer/pouches/factory/support/AbstractPouchDefinition.ts
View File

@ -1,12 +0,0 @@
import {
PouchMetadataAttributeAccessor,
} from '@loafer/pouches';
import {
PouchDefinition,
} from '@loafer/pouches/factory/config';
export abstract class AbstractPouchDefinition extends PouchMetadataAttributeAccessor implements PouchDefinition {
}
export default AbstractPouchDefinition;

7
src/ts/@loafer/pouches/factory/support/AbstractPouchFactory.ts
View File

@ -1,7 +0,0 @@
import AliasRegistry from '@loafer/core/AliasRegistry';
import FactoryPouchRegistrySupport from '@loafer/pouches/factory/support/FactoryPouchRegistrySupport';
export abstract class AbstractPouchFactory extends FactoryPouchRegistrySupport {
}
export default AbstractPouchFactory;

7
src/ts/@loafer/pouches/factory/support/DefaultListablePouchFactory.ts
View File

@ -1,7 +0,0 @@
import AliasRegistry from '@loafer/core/AliasRegistry';
import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
export class DefaultListablePouchFactory implements AliasRegistry {
}
export default DefaultListablePouchFactory;

10
src/ts/@loafer/pouches/factory/support/DefaultSingletonPouchRegistry.ts
View File

@ -1,10 +0,0 @@
import SimpleAliasRegistry from '@loafer/core/SimpleAliasRegistry';
import ObjectFactory from '@loafer/pouches/factory/ObjectFactory';
import DisposablePouch from '@loafer/pouches/factory/DisposablePouch';
import PouchDefinition from '@loafer/pouches/factory/config/PouchDefinition';
import SingletonPouchRegistry from '@loafer/pouches/factory/config/SingletonPouchRegistry';
export class DefaultSingletonPouchRegistry extends SimpleAliasRegistry implements SingletonPouchRegistry {
}
export default DefaultSingletonPouchRegistry;

9
src/ts/@loafer/pouches/factory/support/FactoryPouchRegistrySupport.ts
View File

@ -1,9 +0,0 @@
import AliasRegistry from '@loafer/core/AliasRegistry';
import FactoryPouch from '@loafer/pouches/factory/FactoryPouch';
import DefaultSingletonPouchRegistry from '@loafer/pouches/factory/support/DefaultSingletonPouchRegistry';
export abstract class FactoryPouchRegistrySupport extends DefaultSingletonPouchRegistry {
}
export default FactoryPouchRegistrySupport;

8
src/ts/@loafer/pouches/factory/support/GenericPouchDefinition.ts
View File

@ -1,8 +0,0 @@
import {
AbstractPouchDefinition,
} from '@loafer/pouches/factory/support';
export class GenericPouchDefinition extends AbstractPouchDefinition {
}
export default GenericPouchDefinition;

Some files were not shown because too many files have changed in this diff Show More