@servicetitan/react-ioc 17.1.0 → 17.3.0

package/src/react-ioc.tsx

@@ -1,279 +0,0 @@
-import {
-    Component,
-    useRef,
-    useContext,
-    ReactInstance,
-    StatelessComponent,
-    ComponentClass,
-    ClassicComponentClass,
-    FC,
-} from 'react';
-import { Container, interfaces, METADATA_KEY } from 'inversify';
-import { ContainerContext } from './container-context';
-import { Store } from './store';
-import { Await } from './await';
-import 'reflect-metadata';
-
-export type Token<T> = SymbolToken<T> | interfaces.Newable<T> | interfaces.Abstract<T>;
-
-export type SymbolToken<T> = symbol & { typeRef?: T };
-export function symbolToken<T>(key: string, global = true): SymbolToken<T> {
-    return global ? Symbol.for(key) : Symbol(key);
-}
-
-type ProviderConfigEntry<T> =
-    | interfaces.Newable<T>
-    | ClassProviderConfigEntry<T>
-    | ValueProviderConfigEntry<T>;
-
-interface ClassProviderConfigEntry<T> {
-    provide: Token<T>;
-    useClass: interfaces.Newable<T>;
-}
-
-interface ValueProviderConfigEntry<T> {
-    provide: SymbolToken<T> | interfaces.Abstract<T>;
-    useValue: T;
-}
-
-function isClassProviderConfigEntry<T>(
-    entry: ProviderConfigEntry<T>
-): entry is ClassProviderConfigEntry<T> {
-    return (
-        Object.prototype.hasOwnProperty.call(entry, 'provide') &&
-        Object.prototype.hasOwnProperty.call(entry, 'useClass')
-    );
-}
-
-function isValueProviderConfigEntry<T>(
-    entry: ProviderConfigEntry<T>
-): entry is ValueProviderConfigEntry<T> {
-    return (
-        Object.prototype.hasOwnProperty.call(entry, 'provide') &&
-        Object.prototype.hasOwnProperty.call(entry, 'useValue')
-    );
-}
-
-export interface ProviderInterface {
-    singletons?: ProviderConfigEntry<any>[];
-    instances?: ProviderConfigEntry<any>[];
-    fallback?: JSX.Element;
-}
-
-export interface ProviderComponentInterface extends ProviderInterface {
-    parentContainer: Container;
-}
-
-export interface WrappedComponent<P> {
-    wrappedComponent: ReactComponent<P>;
-    wrappedInstance: ReactInstance | undefined;
-}
-
-type ReactComponent<P = any> = StatelessComponent<P> | ComponentClass<P> | ClassicComponentClass<P>;
-
-type ProvideDecorator = (
-    stores: ProviderInterface
-) => <T extends ReactComponent>(target: T) => T & WrappedComponent<T>;
-
-export const provide = (stores => (Component: ReactComponent) => props =>
-    (
-        <ContainerContext.Consumer>
-            {container => (
-                <ProviderComponent {...stores} parentContainer={container}>
-                    <Component {...props} />
-                </ProviderComponent>
-            )}
-        </ContainerContext.Consumer>
-    )) as ProvideDecorator;
-
-export const Provider: FC<ProviderInterface> = props => (
-    <ContainerContext.Consumer>
-        {container => (
-            <ProviderComponent {...props} parentContainer={container}>
-                {props.children}
-            </ProviderComponent>
-        )}
-    </ContainerContext.Consumer>
-);
-
-class ProviderComponent extends Component<ProviderComponentInterface> {
-    private container: Container;
-
-    private promises: Promise<void>[] = [];
-
-    constructor(props: ProviderComponentInterface) {
-        super(props);
-
-        const { parentContainer, singletons = [], instances = [] } = props;
-
-        this.container = new Container();
-        this.container.parent = parentContainer;
-
-        singletons.map(this.bind).forEach(binding => {
-            binding.inSingletonScope();
-        });
-        instances.forEach(this.bind);
-
-        for (const entry of [...singletons, ...instances]) {
-            if (isValueProviderConfigEntry(entry)) {
-                continue;
-            }
-
-            const identifier = isClassProviderConfigEntry(entry) ? entry.provide : entry;
-            const instance = this.container.get(identifier);
-            if (instance instanceof Store && instance.initialize) {
-                this.promises.push(instance.initialize());
-            }
-        }
-    }
-
-    componentWillUnmount() {
-        const { singletons = [], instances = [] } = this.props;
-
-        for (const entry of [...singletons, ...instances]) {
-            this.unbind(entry);
-        }
-    }
-
-    bind = (entry: ProviderConfigEntry<any>): interfaces.BindingInSyntax<any> => {
-        if (isClassProviderConfigEntry(entry)) {
-            return this.container.bind(entry.provide).to(entry.useClass);
-        }
-
-        if (isValueProviderConfigEntry(entry)) {
-            // using toDynamicValue to return BindingInSyntax
-            return this.container.bind(entry.provide).toDynamicValue(() => entry.useValue);
-        }
-
-        return this.container.bind(entry).to(entry);
-    };
-
-    unbind = (entry: ProviderConfigEntry<any>): void => {
-        if (isValueProviderConfigEntry(entry)) {
-            return this.container.unbind(entry.provide);
-        }
-
-        const identifier = isClassProviderConfigEntry(entry) ? entry.provide : entry;
-        const instance = this.container.get(identifier);
-        if (instance instanceof Store && instance.dispose) {
-            instance.dispose();
-        }
-
-        return this.container.unbind(identifier);
-    };
-
-    render() {
-        const { fallback, children } = this.props;
-
-        return (
-            <ContainerContext.Provider value={this.container}>
-                {this.promises.length ? (
-                    <Await promises={this.promises} fallback={fallback}>
-                        {children}
-                    </Await>
-                ) : (
-                    children
-                )}
-            </ContainerContext.Provider>
-        );
-    }
-}
-
-const INJECTION = Symbol.for('INJECTION');
-
-function proxyGetter(
-    proto: any,
-    key: string,
-    resolve: (componentInstance: any) => any,
-    doCache: boolean
-) {
-    function getter(this: any) {
-        if (doCache && !Reflect.hasMetadata(INJECTION, this, key)) {
-            Reflect.defineMetadata(INJECTION, resolve(this), this, key);
-        }
-        if (Reflect.hasMetadata(INJECTION, this, key)) {
-            return Reflect.getMetadata(INJECTION, this, key);
-        }
-        return resolve(this);
-    }
-    function setter(this: any, newVal: any) {
-        Reflect.defineMetadata(INJECTION, newVal, this, key);
-    }
-    Object.defineProperty(proto, key, {
-        configurable: true,
-        enumerable: true,
-        get: getter,
-        set: setter,
-    });
-}
-
-export function injectDependency(serviceIdentifier: interfaces.ServiceIdentifier<any>) {
-    return function (proto: any, key: string): void {
-        const resolve = (componentInstance: any) => {
-            if (!componentInstance.context) {
-                throw new Error(
-                    "Context doesn't exist on a target class. " +
-                        'Please make sure to pass context object to super method if you access injectable stores in constructor.'
-                );
-            }
-
-            const metadata: Partial<interfaces.MetadataMap> =
-                Reflect.getMetadata(METADATA_KEY.TAGGED_PROP, proto.constructor) || {};
-
-            if (
-                metadata[key]?.some(({ key, value }) => key === METADATA_KEY.OPTIONAL_TAG && value)
-            ) {
-                if (componentInstance.context.isBound(serviceIdentifier)) {
-                    return componentInstance.context.get(serviceIdentifier);
-                }
-            } else {
-                return componentInstance.context.get(serviceIdentifier);
-            }
-        };
-
-        if (proto.constructor.contextType && proto.constructor.contextType !== ContainerContext) {
-            throw new Error(
-                "injectDependency can't be used together with contextType static property"
-            );
-        }
-
-        proto.constructor.contextType = ContainerContext;
-        proxyGetter(proto, key, resolve, true);
-    };
-}
-
-type Tokens<T> = {
-    [P in keyof T]: Token<T[P]>;
-};
-
-function useDependenciesInternal<T extends any[], P extends boolean>(
-    tokens: Tokens<T>,
-    optional: P
-) {
-    const ref = useRef<T | Partial<T> | null>(null);
-    const container = useContext(ContainerContext);
-
-    if (!ref.current) {
-        ref.current = tokens.map(s => {
-            if (optional) {
-                if (container.isBound(s)) {
-                    return container.get(s);
-                }
-
-                return undefined;
-            }
-
-            return container.get(s);
-        }) as T;
-    }
-
-    return ref.current as P extends true ? Partial<T> : T;
-}
-
-export function useDependencies<T extends any[]>(...tokens: Tokens<T>) {
-    return useDependenciesInternal(tokens, false);
-}
-
-export function useOptionalDependencies<T extends any[]>(...tokens: Tokens<T>) {
-    return useDependenciesInternal(tokens, true);
-}