@servicetitan/react-ioc 36.2.0 → 36.3.1

package/dist/dedupe-entries.d.ts

@@ -0,0 +1,9 @@
+import { Token } from './common';
+import { ProviderConfigEntries, ProviderConfigEntryInstances, ProviderConfigEntrySingletons } from './entry-helpers';
+export interface DedupeEntriesResult {
+    duplicates: Token<any>[];
+    singletons: ProviderConfigEntrySingletons<any>[];
+    instances: ProviderConfigEntryInstances<any>[];
+}
+export declare function dedupeEntries({ singletons, instances, }: ProviderConfigEntries): DedupeEntriesResult;
+//# sourceMappingURL=dedupe-entries.d.ts.map

package/dist/dedupe-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe-entries.d.ts","sourceRoot":"","sources":["../src/dedupe-entries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAEH,qBAAqB,EAErB,4BAA4B,EAC5B,6BAA6B,EAChC,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,mBAAmB;IAChC,UAAU,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;IACzB,UAAU,EAAE,6BAA6B,CAAC,GAAG,CAAC,EAAE,CAAC;IACjD,SAAS,EAAE,4BAA4B,CAAC,GAAG,CAAC,EAAE,CAAC;CAClD;AAED,wBAAgB,aAAa,CAAC,EAC1B,UAAe,EACf,SAAc,GACjB,EAAE,qBAAqB,GAAG,mBAAmB,CA+B7C"}

package/dist/dedupe-entries.js

@@ -0,0 +1,35 @@
+import { getProvideToken } from './entry-helpers';
+export function dedupeEntries({ singletons = [], instances = [] }) {
+    const seen = new Set();
+    const duplicates = [];
+    const dedupedSingletons = [];
+    const dedupedInstances = [];
+    function isDuplicate(entry) {
+        const token = getProvideToken(entry);
+        if (!seen.has(token)) {
+            seen.add(token);
+            return false;
+        }
+        if (!duplicates.includes(token)) {
+            duplicates.push(token);
+        }
+        return true;
+    }
+    for (const entry of singletons){
+        if (!isDuplicate(entry)) {
+            dedupedSingletons.push(entry);
+        }
+    }
+    for (const entry of instances){
+        if (!isDuplicate(entry)) {
+            dedupedInstances.push(entry);
+        }
+    }
+    return {
+        duplicates,
+        singletons: dedupedSingletons,
+        instances: dedupedInstances
+    };
+}
+
+//# sourceMappingURL=dedupe-entries.js.map

package/dist/dedupe-entries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dedupe-entries.ts"],"sourcesContent":["import { Token } from './common';\nimport {\n    getProvideToken,\n    ProviderConfigEntries,\n    ProviderConfigEntry,\n    ProviderConfigEntryInstances,\n    ProviderConfigEntrySingletons,\n} from './entry-helpers';\n\nexport interface DedupeEntriesResult {\n    duplicates: Token<any>[];\n    singletons: ProviderConfigEntrySingletons<any>[];\n    instances: ProviderConfigEntryInstances<any>[];\n}\n\nexport function dedupeEntries({\n    singletons = [],\n    instances = [],\n}: ProviderConfigEntries): DedupeEntriesResult {\n    const seen = new Set<Token<any>>();\n    const duplicates: Token<any>[] = [];\n    const dedupedSingletons: ProviderConfigEntrySingletons<any>[] = [];\n    const dedupedInstances: ProviderConfigEntryInstances<any>[] = [];\n\n    function isDuplicate(entry: ProviderConfigEntry<any>): boolean {\n        const token = getProvideToken(entry);\n        if (!seen.has(token)) {\n            seen.add(token);\n            return false;\n        }\n        if (!duplicates.includes(token)) {\n            duplicates.push(token);\n        }\n        return true;\n    }\n\n    for (const entry of singletons) {\n        if (!isDuplicate(entry)) {\n            dedupedSingletons.push(entry);\n        }\n    }\n\n    for (const entry of instances) {\n        if (!isDuplicate(entry)) {\n            dedupedInstances.push(entry);\n        }\n    }\n\n    return { duplicates, singletons: dedupedSingletons, instances: dedupedInstances };\n}\n"],"names":["getProvideToken","dedupeEntries","singletons","instances","seen","Set","duplicates","dedupedSingletons","dedupedInstances","isDuplicate","entry","token","has","add","includes","push"],"mappings":"AACA,SACIA,eAAe,QAKZ,kBAAkB;AAQzB,OAAO,SAASC,cAAc,EAC1BC,aAAa,EAAE,EACfC,YAAY,EAAE,EACM;IACpB,MAAMC,OAAO,IAAIC;IACjB,MAAMC,aAA2B,EAAE;IACnC,MAAMC,oBAA0D,EAAE;IAClE,MAAMC,mBAAwD,EAAE;IAEhE,SAASC,YAAYC,KAA+B;QAChD,MAAMC,QAAQX,gBAAgBU;QAC9B,IAAI,CAACN,KAAKQ,GAAG,CAACD,QAAQ;YAClBP,KAAKS,GAAG,CAACF;YACT,OAAO;QACX;QACA,IAAI,CAACL,WAAWQ,QAAQ,CAACH,QAAQ;YAC7BL,WAAWS,IAAI,CAACJ;QACpB;QACA,OAAO;IACX;IAEA,KAAK,MAAMD,SAASR,WAAY;QAC5B,IAAI,CAACO,YAAYC,QAAQ;YACrBH,kBAAkBQ,IAAI,CAACL;QAC3B;IACJ;IAEA,KAAK,MAAMA,SAASP,UAAW;QAC3B,IAAI,CAACM,YAAYC,QAAQ;YACrBF,iBAAiBO,IAAI,CAACL;QAC1B;IACJ;IAEA,OAAO;QAAEJ;QAAYJ,YAAYK;QAAmBJ,WAAWK;IAAiB;AACpF"}

package/dist/entry-helpers.d.ts

@@ -0,0 +1,33 @@
+import { interfaces } from 'inversify';
+import { SymbolToken, Token } from './common';
+export type ProviderConfigEntrySingletons<T> = ClassProviderConfigEntry<T> | ValueProviderConfigEntry<T>;
+export type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;
+export type ProviderConfigEntry<T> = ProviderConfigEntrySingletons<T> | ProviderConfigEntryInstances<T>;
+export interface ProviderConfigEntries {
+    singletons?: ProviderConfigEntrySingletons<any>[];
+    instances?: ProviderConfigEntryInstances<any>[];
+}
+export type ClassProviderConfigEntry<T> = interfaces.Newable<T> | ClassProviderConfigEntryUseClass<T> | ClassProviderConfigEntryToken<T>;
+export type ClassProviderConfigEntryNoInherit<T> = interfaces.Newable<T> | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;
+export interface ClassProviderConfigEntryUseClass<T> {
+    provide: Token<T>;
+    useClass: interfaces.Newable<T>;
+    inherit?: true;
+}
+export interface ClassProviderConfigEntryToken<T> {
+    provide: interfaces.Newable<T>;
+    inherit?: true;
+}
+export interface ValueProviderConfigEntry<T> {
+    provide: SymbolToken<T> | Function;
+    useValue: T;
+    inherit?: true;
+}
+export declare function formatToken(token: Token<unknown>): string;
+export declare function getProvideToken<T>(entry: ProviderConfigEntry<T>): Token<T>;
+export declare function getProvideTokenWithClass<T>(entry: ProviderConfigEntry<T>): [Token<T>, interfaces.Newable<T>] | [undefined, undefined];
+export declare function isClassProviderConfigEntryToken<T>(entry: ProviderConfigEntry<T>): entry is Omit<ClassProviderConfigEntryToken<T>, 'inherit'>;
+export declare function isClassProviderConfigEntryUseClass<T>(entry: ProviderConfigEntry<T>): entry is Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;
+export declare function isProviderConfigEntryInheritable<T>(entry: ProviderConfigEntry<T>): entry is ClassProviderConfigEntryUseClass<T> | ClassProviderConfigEntryToken<T> | ValueProviderConfigEntry<T>;
+export declare function isValueProviderConfigEntry<T>(entry: ProviderConfigEntry<T>): entry is Omit<ValueProviderConfigEntry<T>, 'inherit'>;
+//# sourceMappingURL=entry-helpers.d.ts.map

package/dist/entry-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-helpers.d.ts","sourceRoot":"","sources":["../src/entry-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,MAAM,6BAA6B,CAAC,CAAC,IACrC,wBAAwB,CAAC,CAAC,CAAC,GAC3B,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAClC,MAAM,MAAM,4BAA4B,CAAC,CAAC,IAAI,iCAAiC,CAAC,CAAC,CAAC,CAAC;AACnF,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC3B,6BAA6B,CAAC,CAAC,CAAC,GAChC,4BAA4B,CAAC,CAAC,CAAC,CAAC;AAEtC,MAAM,WAAW,qBAAqB;IAClC,UAAU,CAAC,EAAE,6BAA6B,CAAC,GAAG,CAAC,EAAE,CAAC;IAClD,SAAS,CAAC,EAAE,4BAA4B,CAAC,GAAG,CAAC,EAAE,CAAC;CACnD;AAED,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAChC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GACrB,gCAAgC,CAAC,CAAC,CAAC,GACnC,6BAA6B,CAAC,CAAC,CAAC,CAAC;AAEvC,MAAM,MAAM,iCAAiC,CAAC,CAAC,IACzC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GACrB,IAAI,CAAC,gCAAgC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAE3D,MAAM,WAAW,gCAAgC,CAAC,CAAC;IAC/C,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B,CAAC,CAAC;IAC5C,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACvC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;IACnC,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CAMzD;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAS1E;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACtC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAc5D;AAED,wBAAgB,+BAA+B,CAAC,CAAC,EAC7C,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,KAAK,IAAI,IAAI,CAAC,6BAA6B,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAM5D;AAED,wBAAgB,kCAAkC,CAAC,CAAC,EAChD,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,KAAK,IAAI,IAAI,CAAC,gCAAgC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAE/D;AAED,wBAAgB,gCAAgC,CAAC,CAAC,EAC9C,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,KAAK,IACF,gCAAgC,CAAC,CAAC,CAAC,GACnC,6BAA6B,CAAC,CAAC,CAAC,GAChC,wBAAwB,CAAC,CAAC,CAAC,CAMhC;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EACxC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,KAAK,IAAI,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAEvD"}

package/dist/entry-helpers.js

@@ -0,0 +1,52 @@
+export function formatToken(token) {
+    if (typeof token === 'symbol') {
+        var _token_description;
+        return (_token_description = token.description) !== null && _token_description !== void 0 ? _token_description : token.toString();
+    }
+    const name = token.name;
+    return name && name.length > 0 ? name : '(anonymous)';
+}
+export function getProvideToken(entry) {
+    if (isClassProviderConfigEntryUseClass(entry) || isClassProviderConfigEntryToken(entry) || isValueProviderConfigEntry(entry)) {
+        return entry.provide;
+    }
+    return entry;
+}
+export function getProvideTokenWithClass(entry) {
+    if (isClassProviderConfigEntryUseClass(entry)) {
+        return [
+            entry.provide,
+            entry.useClass
+        ];
+    }
+    if (isClassProviderConfigEntryToken(entry)) {
+        return [
+            entry.provide,
+            entry.provide
+        ];
+    }
+    if (isValueProviderConfigEntry(entry)) {
+        return [
+            undefined,
+            undefined
+        ];
+    }
+    return [
+        entry,
+        entry
+    ];
+}
+export function isClassProviderConfigEntryToken(entry) {
+    return Object.hasOwn(entry, 'provide') && !Object.hasOwn(entry, 'useClass') && !Object.hasOwn(entry, 'useValue');
+}
+export function isClassProviderConfigEntryUseClass(entry) {
+    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');
+}
+export function isProviderConfigEntryInheritable(entry) {
+    return isClassProviderConfigEntryUseClass(entry) || isClassProviderConfigEntryToken(entry) || isValueProviderConfigEntry(entry);
+}
+export function isValueProviderConfigEntry(entry) {
+    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');
+}
+
+//# sourceMappingURL=entry-helpers.js.map

package/dist/entry-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/entry-helpers.ts"],"sourcesContent":["import { interfaces } from 'inversify';\nimport { SymbolToken, Token } from './common';\n\nexport type ProviderConfigEntrySingletons<T> =\n    | ClassProviderConfigEntry<T>\n    | ValueProviderConfigEntry<T>;\nexport type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;\nexport type ProviderConfigEntry<T> =\n    | ProviderConfigEntrySingletons<T>\n    | ProviderConfigEntryInstances<T>;\n\nexport interface ProviderConfigEntries {\n    singletons?: ProviderConfigEntrySingletons<any>[];\n    instances?: ProviderConfigEntryInstances<any>[];\n}\n\nexport type ClassProviderConfigEntry<T> =\n    | interfaces.Newable<T>\n    | ClassProviderConfigEntryUseClass<T>\n    | ClassProviderConfigEntryToken<T>;\n\nexport type ClassProviderConfigEntryNoInherit<T> =\n    | interfaces.Newable<T>\n    | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;\n\nexport interface ClassProviderConfigEntryUseClass<T> {\n    provide: Token<T>;\n    useClass: interfaces.Newable<T>;\n    inherit?: true;\n}\n\nexport interface ClassProviderConfigEntryToken<T> {\n    provide: interfaces.Newable<T>;\n    inherit?: true;\n}\n\nexport interface ValueProviderConfigEntry<T> {\n    provide: SymbolToken<T> | Function;\n    useValue: T;\n    inherit?: true;\n}\n\nexport function formatToken(token: Token<unknown>): string {\n    if (typeof token === 'symbol') {\n        return token.description ?? token.toString();\n    }\n    const name = (token as Function).name;\n    return name && name.length > 0 ? name : '(anonymous)';\n}\n\nexport function getProvideToken<T>(entry: ProviderConfigEntry<T>): Token<T> {\n    if (\n        isClassProviderConfigEntryUseClass(entry) ||\n        isClassProviderConfigEntryToken(entry) ||\n        isValueProviderConfigEntry(entry)\n    ) {\n        return entry.provide;\n    }\n    return entry;\n}\n\nexport function getProvideTokenWithClass<T>(\n    entry: ProviderConfigEntry<T>\n): [Token<T>, interfaces.Newable<T>] | [undefined, undefined] {\n    if (isClassProviderConfigEntryUseClass(entry)) {\n        return [entry.provide, entry.useClass];\n    }\n\n    if (isClassProviderConfigEntryToken(entry)) {\n        return [entry.provide, entry.provide];\n    }\n\n    if (isValueProviderConfigEntry(entry)) {\n        return [undefined, undefined];\n    }\n\n    return [entry, entry];\n}\n\nexport function isClassProviderConfigEntryToken<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ClassProviderConfigEntryToken<T>, 'inherit'> {\n    return (\n        Object.hasOwn(entry, 'provide') &&\n        !Object.hasOwn(entry, 'useClass') &&\n        !Object.hasOwn(entry, 'useValue')\n    );\n}\n\nexport function isClassProviderConfigEntryUseClass<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'> {\n    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');\n}\n\nexport function isProviderConfigEntryInheritable<T>(\n    entry: ProviderConfigEntry<T>\n): entry is\n    | ClassProviderConfigEntryUseClass<T>\n    | ClassProviderConfigEntryToken<T>\n    | ValueProviderConfigEntry<T> {\n    return (\n        isClassProviderConfigEntryUseClass(entry) ||\n        isClassProviderConfigEntryToken(entry) ||\n        isValueProviderConfigEntry(entry)\n    );\n}\n\nexport function isValueProviderConfigEntry<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ValueProviderConfigEntry<T>, 'inherit'> {\n    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');\n}\n"],"names":["formatToken","token","description","toString","name","length","getProvideToken","entry","isClassProviderConfigEntryUseClass","isClassProviderConfigEntryToken","isValueProviderConfigEntry","provide","getProvideTokenWithClass","useClass","undefined","Object","hasOwn","isProviderConfigEntryInheritable"],"mappings":"AA0CA,OAAO,SAASA,YAAYC,KAAqB;IAC7C,IAAI,OAAOA,UAAU,UAAU;YACpBA;QAAP,QAAOA,qBAAAA,MAAMC,WAAW,cAAjBD,gCAAAA,qBAAqBA,MAAME,QAAQ;IAC9C;IACA,MAAMC,OAAO,AAACH,MAAmBG,IAAI;IACrC,OAAOA,QAAQA,KAAKC,MAAM,GAAG,IAAID,OAAO;AAC5C;AAEA,OAAO,SAASE,gBAAmBC,KAA6B;IAC5D,IACIC,mCAAmCD,UACnCE,gCAAgCF,UAChCG,2BAA2BH,QAC7B;QACE,OAAOA,MAAMI,OAAO;IACxB;IACA,OAAOJ;AACX;AAEA,OAAO,SAASK,yBACZL,KAA6B;IAE7B,IAAIC,mCAAmCD,QAAQ;QAC3C,OAAO;YAACA,MAAMI,OAAO;YAAEJ,MAAMM,QAAQ;SAAC;IAC1C;IAEA,IAAIJ,gCAAgCF,QAAQ;QACxC,OAAO;YAACA,MAAMI,OAAO;YAAEJ,MAAMI,OAAO;SAAC;IACzC;IAEA,IAAID,2BAA2BH,QAAQ;QACnC,OAAO;YAACO;YAAWA;SAAU;IACjC;IAEA,OAAO;QAACP;QAAOA;KAAM;AACzB;AAEA,OAAO,SAASE,gCACZF,KAA6B;IAE7B,OACIQ,OAAOC,MAAM,CAACT,OAAO,cACrB,CAACQ,OAAOC,MAAM,CAACT,OAAO,eACtB,CAACQ,OAAOC,MAAM,CAACT,OAAO;AAE9B;AAEA,OAAO,SAASC,mCACZD,KAA6B;IAE7B,OAAOQ,OAAOC,MAAM,CAACT,OAAO,cAAcQ,OAAOC,MAAM,CAACT,OAAO;AACnE;AAEA,OAAO,SAASU,iCACZV,KAA6B;IAK7B,OACIC,mCAAmCD,UACnCE,gCAAgCF,UAChCG,2BAA2BH;AAEnC;AAEA,OAAO,SAASG,2BACZH,KAA6B;IAE7B,OAAOQ,OAAOC,MAAM,CAACT,OAAO,cAAcQ,OAAOC,MAAM,CAACT,OAAO;AACnE"}

package/dist/provide.d.ts

@@ -1,5 +1,5 @@
 import { ComponentType, ReactInstance, ReactNode } from 'react';
-import { ProviderConfigEntryInstances, ProviderConfigEntrySingletons } from './provider';
+import { ProviderConfigEntries } from './entry-helpers';
 export interface WrappedComponent<P> {
     wrappedComponent: ComponentType<P>;
     wrappedInstance: ReactInstance | undefined;
@@ -8,9 +8,6 @@ export interface FallbackOptions {
     loadingFallback?: ReactNode;
     errorFallback?: ReactNode;
 }
-export type ProvideDecorator = (stores: {
-    singletons?: ProviderConfigEntrySingletons<any>[];
-    instances?: ProviderConfigEntryInstances<any>[];
-}, options?: ReactNode | FallbackOptions) => <T extends ComponentType<any>>(target: T) => T & WrappedComponent<T>;
+export type ProvideDecorator = (stores: ProviderConfigEntries, options?: ReactNode | FallbackOptions) => <T extends ComponentType<any>>(target: T) => T & WrappedComponent<T>;
 export declare const provide: ProvideDecorator;
 //# sourceMappingURL=provide.d.ts.map

package/dist/provide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provide.d.ts","sourceRoot":"","sources":["../src/provide.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAChE,OAAO,EAAY,4BAA4B,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEnG,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B,gBAAgB,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACnC,eAAe,EAAE,aAAa,GAAG,SAAS,CAAC;CAC9C;AAED,MAAM,WAAW,eAAe;IAC5B,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,aAAa,CAAC,EAAE,SAAS,CAAC;CAC7B;AAED,MAAM,MAAM,gBAAgB,GAAG,CAC3B,MAAM,EAAE;IACJ,UAAU,CAAC,EAAE,6BAA6B,CAAC,GAAG,CAAC,EAAE,CAAC;IAClD,SAAS,CAAC,EAAE,4BAA4B,CAAC,GAAG,CAAC,EAAE,CAAC;CACnD,EACD,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,KACpC,CAAC,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAE1E,eAAO,MAAM,OAAO,EAId,gBAAgB,CAAC"}
+{"version":3,"file":"provide.d.ts","sourceRoot":"","sources":["../src/provide.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAGxD,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B,gBAAgB,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACnC,eAAe,EAAE,aAAa,GAAG,SAAS,CAAC;CAC9C;AAED,MAAM,WAAW,eAAe;IAC5B,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,aAAa,CAAC,EAAE,SAAS,CAAC;CAC7B;AAED,MAAM,MAAM,gBAAgB,GAAG,CAC3B,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,KACpC,CAAC,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAE1E,eAAO,MAAM,OAAO,EAId,gBAAgB,CAAC"}

package/dist/provide.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/provide.tsx"],"sourcesContent":["import { ComponentType, ReactInstance, ReactNode } from 'react';\nimport { Provider, ProviderConfigEntryInstances, ProviderConfigEntrySingletons } from './provider';\n\nexport interface WrappedComponent<P> {\n    wrappedComponent: ComponentType<P>;\n    wrappedInstance: ReactInstance | undefined;\n}\n\nexport interface FallbackOptions {\n    loadingFallback?: ReactNode;\n    errorFallback?: ReactNode;\n}\n\nexport type ProvideDecorator = (\n    stores: {\n        singletons?: ProviderConfigEntrySingletons<any>[];\n        instances?: ProviderConfigEntryInstances<any>[];\n    },\n    options?: ReactNode | FallbackOptions\n) => <T extends ComponentType<any>>(target: T) => T & WrappedComponent<T>;\n\nexport const provide = ((stores, elementOrOptions) => (Component: ComponentType) => props => (\n    <Provider {...stores} {...getOptions(elementOrOptions)}>\n        <Component {...props} />\n    </Provider>\n)) as ProvideDecorator;\n\nfunction getOptions(arg?: FallbackOptions | ReactNode): FallbackOptions | undefined {\n    return arg && isOptionsObject(arg) ? arg : { loadingFallback: arg };\n}\n\nfunction isOptionsObject(arg: FallbackOptions | NonNullable<ReactNode>): arg is FallbackOptions {\n    return (\n        typeof arg === 'object' &&\n        (Object.hasOwn(arg, 'loadingFallback') ||\n            Object.hasOwn(arg, 'errorFallback') ||\n            Object.keys(arg).length === 0)\n    );\n}\n"],"names":["Provider","provide","stores","elementOrOptions","Component","props","getOptions","arg","isOptionsObject","loadingFallback","Object","hasOwn","keys","length"],"mappings":";AACA,SAASA,QAAQ,QAAqE,aAAa;AAoBnG,OAAO,MAAMC,UAAW,CAACC,QAAQC,mBAAqB,CAACC,YAA6BC,CAAAA,sBAChF,KAACL;gBAAU,GAAGE,MAAM;gBAAG,GAAGI,WAAWH,iBAAiB;0BAClD,cAAA,KAACC;oBAAW,GAAGC,KAAK;;eAEL;AAEvB,SAASC,WAAWC,GAAiC;IACjD,OAAOA,OAAOC,gBAAgBD,OAAOA,MAAM;QAAEE,iBAAiBF;IAAI;AACtE;AAEA,SAASC,gBAAgBD,GAA6C;IAClE,OACI,OAAOA,QAAQ,YACdG,CAAAA,OAAOC,MAAM,CAACJ,KAAK,sBAChBG,OAAOC,MAAM,CAACJ,KAAK,oBACnBG,OAAOE,IAAI,CAACL,KAAKM,MAAM,KAAK,CAAA;AAExC"}
+{"version":3,"sources":["../src/provide.tsx"],"sourcesContent":["import { ComponentType, ReactInstance, ReactNode } from 'react';\nimport { ProviderConfigEntries } from './entry-helpers';\nimport { Provider } from './provider';\n\nexport interface WrappedComponent<P> {\n    wrappedComponent: ComponentType<P>;\n    wrappedInstance: ReactInstance | undefined;\n}\n\nexport interface FallbackOptions {\n    loadingFallback?: ReactNode;\n    errorFallback?: ReactNode;\n}\n\nexport type ProvideDecorator = (\n    stores: ProviderConfigEntries,\n    options?: ReactNode | FallbackOptions\n) => <T extends ComponentType<any>>(target: T) => T & WrappedComponent<T>;\n\nexport const provide = ((stores, elementOrOptions) => (Component: ComponentType) => props => (\n    <Provider {...stores} {...getOptions(elementOrOptions)}>\n        <Component {...props} />\n    </Provider>\n)) as ProvideDecorator;\n\nfunction getOptions(arg?: FallbackOptions | ReactNode): FallbackOptions | undefined {\n    return arg && isOptionsObject(arg) ? arg : { loadingFallback: arg };\n}\n\nfunction isOptionsObject(arg: FallbackOptions | NonNullable<ReactNode>): arg is FallbackOptions {\n    return (\n        typeof arg === 'object' &&\n        (Object.hasOwn(arg, 'loadingFallback') ||\n            Object.hasOwn(arg, 'errorFallback') ||\n            Object.keys(arg).length === 0)\n    );\n}\n"],"names":["Provider","provide","stores","elementOrOptions","Component","props","getOptions","arg","isOptionsObject","loadingFallback","Object","hasOwn","keys","length"],"mappings":";AAEA,SAASA,QAAQ,QAAQ,aAAa;AAiBtC,OAAO,MAAMC,UAAW,CAACC,QAAQC,mBAAqB,CAACC,YAA6BC,CAAAA,sBAChF,KAACL;gBAAU,GAAGE,MAAM;gBAAG,GAAGI,WAAWH,iBAAiB;0BAClD,cAAA,KAACC;oBAAW,GAAGC,KAAK;;eAEL;AAEvB,SAASC,WAAWC,GAAiC;IACjD,OAAOA,OAAOC,gBAAgBD,OAAOA,MAAM;QAAEE,iBAAiBF;IAAI;AACtE;AAEA,SAASC,gBAAgBD,GAA6C;IAClE,OACI,OAAOA,QAAQ,YACdG,CAAAA,OAAOC,MAAM,CAACJ,KAAK,sBAChBG,OAAOC,MAAM,CAACJ,KAAK,oBACnBG,OAAOE,IAAI,CAACL,KAAKM,MAAM,KAAK,CAAA;AAExC"}

package/dist/provider.d.ts

@@ -1,31 +1,8 @@
-import { interfaces } from 'inversify';
 import { FC, PropsWithChildren, ReactNode } from 'react';
-import { SymbolToken, Token } from './common';
-export type ProviderConfigEntrySingletons<T> = ClassProviderConfigEntry<T> | ValueProviderConfigEntry<T>;
-export type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;
-export type ProviderConfigEntry<T> = ProviderConfigEntrySingletons<T> | ProviderConfigEntryInstances<T>;
-type ClassProviderConfigEntry<T> = interfaces.Newable<T> | ClassProviderConfigEntryUseClass<T> | ClassProviderConfigEntryToken<T>;
-type ClassProviderConfigEntryNoInherit<T> = interfaces.Newable<T> | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;
-interface ClassProviderConfigEntryUseClass<T> {
-    provide: Token<T>;
-    useClass: interfaces.Newable<T>;
-    inherit?: true;
-}
-interface ClassProviderConfigEntryToken<T> {
-    provide: interfaces.Newable<T>;
-    inherit?: true;
-}
-interface ValueProviderConfigEntry<T> {
-    provide: SymbolToken<T> | Function;
-    useValue: T;
-    inherit?: true;
-}
-export type ProviderProps = PropsWithChildren<{
-    singletons?: ProviderConfigEntrySingletons<any>[];
-    instances?: ProviderConfigEntryInstances<any>[];
+import { ProviderConfigEntries } from './entry-helpers';
+export type ProviderProps = PropsWithChildren<ProviderConfigEntries & {
     loadingFallback?: ReactNode;
     errorFallback?: ReactNode;
 }>;
 export declare const Provider: FC<ProviderProps>;
-export {};
 //# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,UAAU,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,EAAE,EAAE,iBAAiB,EAAE,SAAS,EAAmC,MAAM,OAAO,CAAC;AAE1F,OAAO,EAAoB,WAAW,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAIhE,MAAM,MAAM,6BAA6B,CAAC,CAAC,IACrC,wBAAwB,CAAC,CAAC,CAAC,GAC3B,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAClC,MAAM,MAAM,4BAA4B,CAAC,CAAC,IAAI,iCAAiC,CAAC,CAAC,CAAC,CAAC;AACnF,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC3B,6BAA6B,CAAC,CAAC,CAAC,GAChC,4BAA4B,CAAC,CAAC,CAAC,CAAC;AAEtC,KAAK,wBAAwB,CAAC,CAAC,IACzB,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GACrB,gCAAgC,CAAC,CAAC,CAAC,GACnC,6BAA6B,CAAC,CAAC,CAAC,CAAC;AAEvC,KAAK,iCAAiC,CAAC,CAAC,IAClC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GACrB,IAAI,CAAC,gCAAgC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAE3D,UAAU,gCAAgC,CAAC,CAAC;IACxC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,UAAU,6BAA6B,CAAC,CAAC;IACrC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,UAAU,wBAAwB,CAAC,CAAC;IAChC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;IACnC,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AA2JD,MAAM,MAAM,aAAa,GAAG,iBAAiB,CAAC;IAC1C,UAAU,CAAC,EAAE,6BAA6B,CAAC,GAAG,CAAC,EAAE,CAAC;IAClD,SAAS,CAAC,EAAE,4BAA4B,CAAC,GAAG,CAAC,EAAE,CAAC;IAChD,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,aAAa,CAAC,EAAE,SAAS,CAAC;CAC7B,CAAC,CAAC;AAEH,eAAO,MAAM,QAAQ,EAAE,EAAE,CAAC,aAAa,CA+DtC,CAAC"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,iBAAiB,EAAE,SAAS,EAAmC,MAAM,OAAO,CAAC;AAI1F,OAAO,EAOH,qBAAqB,EAExB,MAAM,iBAAiB,CAAC;AA6GzB,MAAM,MAAM,aAAa,GAAG,iBAAiB,CACzC,qBAAqB,GAAG;IACpB,eAAe,CAAC,EAAE,SAAS,CAAC;IAC5B,aAAa,CAAC,EAAE,SAAS,CAAC;CAC7B,CACJ,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,EAAE,CAAC,aAAa,CA2EtC,CAAC"}

package/dist/provider.js

@@ -3,44 +3,10 @@ import { Container } from 'inversify';
 import { useContext, useEffect, useState } from 'react';
 import { Await } from './await';
 import { ContainerContext } from './common';
+import { dedupeEntries } from './dedupe-entries';
+import { formatToken, getProvideTokenWithClass, isClassProviderConfigEntryToken, isClassProviderConfigEntryUseClass, isProviderConfigEntryInheritable, isValueProviderConfigEntry } from './entry-helpers';
 import { defaultErrorFallback, defaultLoadingFallback } from './fallbacks';
 import { isStore } from './store';
-function isClassProviderConfigEntryUseClass(entry) {
-    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');
-}
-function isValueProviderConfigEntry(entry) {
-    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');
-}
-function isClassProviderConfigEntryToken(entry) {
-    return Object.hasOwn(entry, 'provide') && !Object.hasOwn(entry, 'useClass') && !Object.hasOwn(entry, 'useValue');
-}
-function isProviderConfigEntryInheritable(entry) {
-    return isClassProviderConfigEntryUseClass(entry) || isClassProviderConfigEntryToken(entry) || isValueProviderConfigEntry(entry);
-}
-function getProvideTokenWithClass(entry) {
-    if (isClassProviderConfigEntryUseClass(entry)) {
-        return [
-            entry.provide,
-            entry.useClass
-        ];
-    }
-    if (isClassProviderConfigEntryToken(entry)) {
-        return [
-            entry.provide,
-            entry.provide
-        ];
-    }
-    if (isValueProviderConfigEntry(entry)) {
-        return [
-            undefined,
-            undefined
-        ];
-    }
-    return [
-        entry,
-        entry
-    ];
-}
 function getStoreInstances(container, { singletons = [], instances = [] }) {
     return [
         ...singletons,
@@ -112,6 +78,10 @@ function disposeStores(stores) {
         (_instance_dispose = instance.dispose) === null || _instance_dispose === void 0 ? void 0 : _instance_dispose.call(instance);
     }
 }
+function formatDuplicatesMessage(duplicates) {
+    const names = duplicates.map(formatToken).join(', ');
+    return `Provider: token listed more than once: ${names}. Remove the duplicate entries.`;
+}
 export const Provider = ({ singletons, instances, loadingFallback = defaultLoadingFallback, errorFallback = defaultErrorFallback, children })=>{
     const parentContainer = useContext(ContainerContext);
     const [container, setContainer] = useState();
@@ -128,24 +98,28 @@ export const Provider = ({ singletons, instances, loadingFallback = defaultLoadi
                 throw e;
             });
         };
-        bindEntries(container, {
+        const config = dedupeEntries({
             singletons,
             instances
         });
-        const promises = initializeStores(getStoreInstances(container, {
-            singletons,
-            instances
-        }), handleError);
+        if (config.duplicates.length > 0) {
+            const message = formatDuplicatesMessage(config.duplicates);
+            if (process.env.NODE_ENV !== 'production') {
+                handleError(new Error(message));
+                return ()=>{
+                    setContainer(undefined);
+                    setPromises([]);
+                };
+            }
+            // eslint-disable-next-line no-console
+            console.warn(message);
+        }
+        bindEntries(container, config);
+        const promises = initializeStores(getStoreInstances(container, config), handleError);
         setPromises(promises);
         return ()=>{
-            const storeInstances = getStoreInstances(container, {
-                singletons,
-                instances
-            });
-            unbindEntries(container, {
-                singletons,
-                instances
-            });
+            const storeInstances = getStoreInstances(container, config);
+            unbindEntries(container, config);
             disposeStores(storeInstances);
             setContainer(undefined);
             setPromises([]);

package/dist/provider.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/provider.tsx"],"sourcesContent":["import { Container, interfaces } from 'inversify';\nimport { FC, PropsWithChildren, ReactNode, useContext, useEffect, useState } from 'react';\nimport { Await } from './await';\nimport { ContainerContext, SymbolToken, Token } from './common';\nimport { defaultErrorFallback, defaultLoadingFallback } from './fallbacks';\nimport { isStore, Store } from './store';\n\nexport type ProviderConfigEntrySingletons<T> =\n    | ClassProviderConfigEntry<T>\n    | ValueProviderConfigEntry<T>;\nexport type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;\nexport type ProviderConfigEntry<T> =\n    | ProviderConfigEntrySingletons<T>\n    | ProviderConfigEntryInstances<T>;\n\ntype ClassProviderConfigEntry<T> =\n    | interfaces.Newable<T>\n    | ClassProviderConfigEntryUseClass<T>\n    | ClassProviderConfigEntryToken<T>;\n\ntype ClassProviderConfigEntryNoInherit<T> =\n    | interfaces.Newable<T>\n    | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;\n\ninterface ClassProviderConfigEntryUseClass<T> {\n    provide: Token<T>;\n    useClass: interfaces.Newable<T>;\n    inherit?: true;\n}\n\ninterface ClassProviderConfigEntryToken<T> {\n    provide: interfaces.Newable<T>;\n    inherit?: true;\n}\n\ninterface ValueProviderConfigEntry<T> {\n    provide: SymbolToken<T> | Function;\n    useValue: T;\n    inherit?: true;\n}\n\nfunction isClassProviderConfigEntryUseClass<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'> {\n    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');\n}\n\nfunction isValueProviderConfigEntry<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ValueProviderConfigEntry<T>, 'inherit'> {\n    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');\n}\n\nfunction isClassProviderConfigEntryToken<T>(\n    entry: ProviderConfigEntry<T>\n): entry is Omit<ClassProviderConfigEntryToken<T>, 'inherit'> {\n    return (\n        Object.hasOwn(entry, 'provide') &&\n        !Object.hasOwn(entry, 'useClass') &&\n        !Object.hasOwn(entry, 'useValue')\n    );\n}\n\nfunction isProviderConfigEntryInheritable<T>(\n    entry: ProviderConfigEntry<T>\n): entry is\n    | ClassProviderConfigEntryUseClass<T>\n    | ClassProviderConfigEntryToken<T>\n    | ValueProviderConfigEntry<T> {\n    return (\n        isClassProviderConfigEntryUseClass(entry) ||\n        isClassProviderConfigEntryToken(entry) ||\n        isValueProviderConfigEntry(entry)\n    );\n}\n\nfunction getProvideTokenWithClass<T>(\n    entry: ProviderConfigEntry<T>\n): [Token<T>, interfaces.Newable<T>] | [undefined, undefined] {\n    if (isClassProviderConfigEntryUseClass(entry)) {\n        return [entry.provide, entry.useClass];\n    }\n\n    if (isClassProviderConfigEntryToken(entry)) {\n        return [entry.provide, entry.provide];\n    }\n\n    if (isValueProviderConfigEntry(entry)) {\n        return [undefined, undefined];\n    }\n\n    return [entry, entry];\n}\n\nfunction getStoreInstances(\n    container: Container,\n    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>\n): Store[] {\n    return [...singletons, ...instances].reduce((out, entry) => {\n        const [provide, useClass] = getProvideTokenWithClass(entry);\n\n        if (provide && useClass && container.isCurrentBound(provide) && isStore(useClass)) {\n            out.push(container.get(provide));\n        }\n\n        return out;\n    }, [] as Store[]);\n}\n\nconst bindEntry =\n    (container: Container, checkInherit: boolean) => (entry: ProviderConfigEntry<any>) => {\n        if (\n            checkInherit &&\n            isProviderConfigEntryInheritable(entry) &&\n            entry.inherit &&\n            container.isBound(entry.provide)\n        ) {\n            return undefined;\n        }\n\n        if (isClassProviderConfigEntryUseClass(entry)) {\n            return container.bind(entry.provide).to(entry.useClass);\n        }\n\n        if (isClassProviderConfigEntryToken(entry)) {\n            return container.bind(entry.provide).to(entry.provide);\n        }\n\n        if (isValueProviderConfigEntry(entry)) {\n            // using toDynamicValue to return BindingInSyntax\n            return container.bind(entry.provide).toDynamicValue(() => entry.useValue);\n        }\n\n        return container.bind(entry).to(entry);\n    };\n\nconst unbindEntry = (container: Container) => (entry: ProviderConfigEntry<any>) => {\n    if (isProviderConfigEntryInheritable(entry) && !container.isCurrentBound(entry.provide)) {\n        return;\n    }\n    if (\n        isClassProviderConfigEntryUseClass(entry) ||\n        isValueProviderConfigEntry(entry) ||\n        isClassProviderConfigEntryToken(entry)\n    ) {\n        return container.unbind(entry.provide);\n    }\n\n    return container.unbind(entry);\n};\n\nfunction bindEntries(\n    container: Container,\n    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>\n) {\n    singletons.map(bindEntry(container, true)).forEach(binding => {\n        binding?.inSingletonScope();\n    });\n    instances.forEach(bindEntry(container, false));\n}\n\nfunction unbindEntries(\n    container: Container,\n    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>\n) {\n    [...singletons, ...instances].forEach(unbindEntry(container));\n}\n\nfunction initializeStores(stores: Store[], onError: (error: any) => void) {\n    const promises: Promise<void>[] = [];\n\n    for (const instance of stores) {\n        let promise;\n\n        try {\n            promise = instance.initialize?.();\n        } catch (e: any) {\n            onError(e);\n        }\n\n        if (promise && typeof promise.catch === 'function') {\n            promises.push(promise.catch(onError));\n        }\n    }\n\n    return promises;\n}\n\nfunction disposeStores(stores: Store[]) {\n    for (const instance of stores) {\n        instance.dispose?.();\n    }\n}\n\nexport type ProviderProps = PropsWithChildren<{\n    singletons?: ProviderConfigEntrySingletons<any>[];\n    instances?: ProviderConfigEntryInstances<any>[];\n    loadingFallback?: ReactNode;\n    errorFallback?: ReactNode;\n}>;\n\nexport const Provider: FC<ProviderProps> = ({\n    singletons,\n    instances,\n    loadingFallback = defaultLoadingFallback,\n    errorFallback = defaultErrorFallback,\n    children,\n}) => {\n    const parentContainer = useContext(ContainerContext);\n    const [container, setContainer] = useState<Container>();\n    const [promises, setPromises] = useState<Promise<void>[]>([]);\n    const [error, setError] = useState(false);\n\n    useEffect(() => {\n        const container = new Container();\n        container.parent = parentContainer;\n        setContainer(container);\n\n        const handleError = (e: any) => {\n            setError(true);\n            // Rethrow asynchronously for global error handler\n            setTimeout(() => {\n                throw e;\n            });\n        };\n\n        bindEntries(container, { singletons, instances });\n        const promises = initializeStores(\n            getStoreInstances(container, { singletons, instances }),\n            handleError\n        );\n        setPromises(promises);\n\n        return () => {\n            const storeInstances = getStoreInstances(container, { singletons, instances });\n\n            unbindEntries(container, { singletons, instances });\n            disposeStores(storeInstances);\n            setContainer(undefined);\n            setPromises([]);\n        };\n    }, []); // eslint-disable-line react-hooks/exhaustive-deps\n\n    if (!container) {\n        return null;\n    }\n\n    const getContent = () => {\n        if (error) {\n            return errorFallback;\n        }\n\n        if (promises.length) {\n            return (\n                <Await promises={promises} fallback={loadingFallback}>\n                    {children}\n                </Await>\n            );\n        }\n\n        return children;\n    };\n\n    return <ContainerContext.Provider value={container}>{getContent()}</ContainerContext.Provider>;\n};\n"],"names":["Container","useContext","useEffect","useState","Await","ContainerContext","defaultErrorFallback","defaultLoadingFallback","isStore","isClassProviderConfigEntryUseClass","entry","Object","hasOwn","isValueProviderConfigEntry","isClassProviderConfigEntryToken","isProviderConfigEntryInheritable","getProvideTokenWithClass","provide","useClass","undefined","getStoreInstances","container","singletons","instances","reduce","out","isCurrentBound","push","get","bindEntry","checkInherit","inherit","isBound","bind","to","toDynamicValue","useValue","unbindEntry","unbind","bindEntries","map","forEach","binding","inSingletonScope","unbindEntries","initializeStores","stores","onError","promises","instance","promise","initialize","e","catch","disposeStores","dispose","Provider","loadingFallback","errorFallback","children","parentContainer","setContainer","setPromises","error","setError","parent","handleError","setTimeout","storeInstances","getContent","length","fallback","value"],"mappings":"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"}
+{"version":3,"sources":["../src/provider.tsx"],"sourcesContent":["import { Container } from 'inversify';\nimport { FC, PropsWithChildren, ReactNode, useContext, useEffect, useState } from 'react';\nimport { Await } from './await';\nimport { ContainerContext, Token } from './common';\nimport { dedupeEntries } from './dedupe-entries';\nimport {\n    formatToken,\n    getProvideTokenWithClass,\n    isClassProviderConfigEntryToken,\n    isClassProviderConfigEntryUseClass,\n    isProviderConfigEntryInheritable,\n    isValueProviderConfigEntry,\n    ProviderConfigEntries,\n    ProviderConfigEntry,\n} from './entry-helpers';\nimport { defaultErrorFallback, defaultLoadingFallback } from './fallbacks';\nimport { isStore, Store } from './store';\n\nfunction getStoreInstances(\n    container: Container,\n    { singletons = [], instances = [] }: ProviderConfigEntries\n): Store[] {\n    return [...singletons, ...instances].reduce((out, entry) => {\n        const [provide, useClass] = getProvideTokenWithClass(entry);\n\n        if (provide && useClass && container.isCurrentBound(provide) && isStore(useClass)) {\n            out.push(container.get(provide));\n        }\n\n        return out;\n    }, [] as Store[]);\n}\n\nconst bindEntry =\n    (container: Container, checkInherit: boolean) => (entry: ProviderConfigEntry<any>) => {\n        if (\n            checkInherit &&\n            isProviderConfigEntryInheritable(entry) &&\n            entry.inherit &&\n            container.isBound(entry.provide)\n        ) {\n            return undefined;\n        }\n\n        if (isClassProviderConfigEntryUseClass(entry)) {\n            return container.bind(entry.provide).to(entry.useClass);\n        }\n\n        if (isClassProviderConfigEntryToken(entry)) {\n            return container.bind(entry.provide).to(entry.provide);\n        }\n\n        if (isValueProviderConfigEntry(entry)) {\n            // using toDynamicValue to return BindingInSyntax\n            return container.bind(entry.provide).toDynamicValue(() => entry.useValue);\n        }\n\n        return container.bind(entry).to(entry);\n    };\n\nconst unbindEntry = (container: Container) => (entry: ProviderConfigEntry<any>) => {\n    if (isProviderConfigEntryInheritable(entry) && !container.isCurrentBound(entry.provide)) {\n        return;\n    }\n    if (\n        isClassProviderConfigEntryUseClass(entry) ||\n        isValueProviderConfigEntry(entry) ||\n        isClassProviderConfigEntryToken(entry)\n    ) {\n        return container.unbind(entry.provide);\n    }\n\n    return container.unbind(entry);\n};\n\nfunction bindEntries(\n    container: Container,\n    { singletons = [], instances = [] }: ProviderConfigEntries\n) {\n    singletons.map(bindEntry(container, true)).forEach(binding => {\n        binding?.inSingletonScope();\n    });\n    instances.forEach(bindEntry(container, false));\n}\n\nfunction unbindEntries(\n    container: Container,\n    { singletons = [], instances = [] }: ProviderConfigEntries\n) {\n    [...singletons, ...instances].forEach(unbindEntry(container));\n}\n\nfunction initializeStores(stores: Store[], onError: (error: any) => void) {\n    const promises: Promise<void>[] = [];\n\n    for (const instance of stores) {\n        let promise;\n\n        try {\n            promise = instance.initialize?.();\n        } catch (e: any) {\n            onError(e);\n        }\n\n        if (promise && typeof promise.catch === 'function') {\n            promises.push(promise.catch(onError));\n        }\n    }\n\n    return promises;\n}\n\nfunction disposeStores(stores: Store[]) {\n    for (const instance of stores) {\n        instance.dispose?.();\n    }\n}\n\nfunction formatDuplicatesMessage(duplicates: Token<any>[]): string {\n    const names = duplicates.map(formatToken).join(', ');\n    return `Provider: token listed more than once: ${names}. Remove the duplicate entries.`;\n}\n\nexport type ProviderProps = PropsWithChildren<\n    ProviderConfigEntries & {\n        loadingFallback?: ReactNode;\n        errorFallback?: ReactNode;\n    }\n>;\n\nexport const Provider: FC<ProviderProps> = ({\n    singletons,\n    instances,\n    loadingFallback = defaultLoadingFallback,\n    errorFallback = defaultErrorFallback,\n    children,\n}) => {\n    const parentContainer = useContext(ContainerContext);\n    const [container, setContainer] = useState<Container>();\n    const [promises, setPromises] = useState<Promise<void>[]>([]);\n    const [error, setError] = useState(false);\n\n    useEffect(() => {\n        const container = new Container();\n        container.parent = parentContainer;\n        setContainer(container);\n\n        const handleError = (e: any) => {\n            setError(true);\n            // Rethrow asynchronously for global error handler\n            setTimeout(() => {\n                throw e;\n            });\n        };\n\n        const config = dedupeEntries({ singletons, instances });\n\n        if (config.duplicates.length > 0) {\n            const message = formatDuplicatesMessage(config.duplicates);\n            if (process.env.NODE_ENV !== 'production') {\n                handleError(new Error(message));\n                return () => {\n                    setContainer(undefined);\n                    setPromises([]);\n                };\n            }\n            // eslint-disable-next-line no-console\n            console.warn(message);\n        }\n\n        bindEntries(container, config);\n        const promises = initializeStores(getStoreInstances(container, config), handleError);\n        setPromises(promises);\n\n        return () => {\n            const storeInstances = getStoreInstances(container, config);\n\n            unbindEntries(container, config);\n            disposeStores(storeInstances);\n            setContainer(undefined);\n            setPromises([]);\n        };\n    }, []); // eslint-disable-line react-hooks/exhaustive-deps\n\n    if (!container) {\n        return null;\n    }\n\n    const getContent = () => {\n        if (error) {\n            return errorFallback;\n        }\n\n        if (promises.length) {\n            return (\n                <Await promises={promises} fallback={loadingFallback}>\n                    {children}\n                </Await>\n            );\n        }\n\n        return children;\n    };\n\n    return <ContainerContext.Provider value={container}>{getContent()}</ContainerContext.Provider>;\n};\n"],"names":["Container","useContext","useEffect","useState","Await","ContainerContext","dedupeEntries","formatToken","getProvideTokenWithClass","isClassProviderConfigEntryToken","isClassProviderConfigEntryUseClass","isProviderConfigEntryInheritable","isValueProviderConfigEntry","defaultErrorFallback","defaultLoadingFallback","isStore","getStoreInstances","container","singletons","instances","reduce","out","entry","provide","useClass","isCurrentBound","push","get","bindEntry","checkInherit","inherit","isBound","undefined","bind","to","toDynamicValue","useValue","unbindEntry","unbind","bindEntries","map","forEach","binding","inSingletonScope","unbindEntries","initializeStores","stores","onError","promises","instance","promise","initialize","e","catch","disposeStores","dispose","formatDuplicatesMessage","duplicates","names","join","Provider","loadingFallback","errorFallback","children","parentContainer","setContainer","setPromises","error","setError","parent","handleError","setTimeout","config","length","message","process","env","NODE_ENV","Error","console","warn","storeInstances","getContent","fallback","value"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/react-ioc",
-    "version": "36.2.0",
+    "version": "36.3.1",
     "description": "Implementation of InversifyJS for React applications using Context API",
     "homepage": "https://docs.st.dev/docs/frontend/uikit/react-ioc",
     "repository": {
@@ -35,5 +35,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "87254b2caf60b20eb46c33b40ffb4dd05ad3e0f7"
+    "gitHead": "93a049ba1e5cb737afb7bc95c06020736bc61a38"
 }

package/src/__tests__/dedupe-entries.test.ts

@@ -0,0 +1,143 @@
+import { symbolToken } from '../common';
+import { dedupeEntries } from '../dedupe-entries';
+
+class StoreA {}
+class StoreB {}
+class StoreC {}
+
+describe('[react-ioc] dedupeEntries', () => {
+    let singletons: any;
+    let instances: any;
+
+    beforeEach(() => {
+        singletons = undefined;
+        instances = undefined;
+    });
+
+    const subject = () => dedupeEntries({ singletons, instances });
+
+    describe('with empty input', () => {
+        test('reports no duplicates', () => {
+            expect(subject().duplicates).toEqual([]);
+        });
+
+        test('returns empty singletons', () => {
+            expect(subject().singletons).toEqual([]);
+        });
+
+        test('returns empty instances', () => {
+            expect(subject().instances).toEqual([]);
+        });
+    });
+
+    describe('with all distinct tokens', () => {
+        beforeEach(() => {
+            singletons = [StoreA, { provide: StoreB }];
+            instances = [StoreC];
+        });
+
+        test('reports no duplicates', () => {
+            expect(subject().duplicates).toEqual([]);
+        });
+
+        test('returns singletons unchanged', () => {
+            expect(subject().singletons).toEqual(singletons);
+        });
+
+        test('returns instances unchanged', () => {
+            expect(subject().instances).toEqual(instances);
+        });
+    });
+
+    function itReturnsDuplicatedToken() {
+        test('returns the duplicate token', () => {
+            const token = singletons[0].provide ?? singletons[0];
+            expect(subject().duplicates).toEqual([token]);
+        });
+    }
+
+    function itReturnsDedupedSingletons() {
+        test('returns deduped singletons', () => {
+            expect(subject().singletons).toEqual(singletons?.slice(0, 1));
+        });
+    }
+
+    describe('with duplicate class', () => {
+        beforeEach(() => (singletons = [StoreA, StoreA]));
+
+        itReturnsDuplicatedToken();
+        itReturnsDedupedSingletons();
+    });
+
+    describe('with duplicate class and provide entry', () => {
+        beforeEach(() => {
+            singletons = [StoreA, { provide: StoreA }];
+        });
+
+        itReturnsDuplicatedToken();
+        itReturnsDedupedSingletons();
+    });
+
+    describe('with duplicate provide entries', () => {
+        beforeEach(() => {
+            singletons = [
+                { provide: StoreA, useClass: StoreB },
+                { provide: StoreA, useClass: StoreC },
+            ];
+        });
+
+        itReturnsDuplicatedToken();
+        itReturnsDedupedSingletons();
+    });
+
+    describe('with duplicate useValue entries', () => {
+        const valueToken = symbolToken<{ kind: string }>('test/value');
+
+        beforeEach(() => {
+            singletons = [
+                { provide: valueToken, useValue: { kind: 'first' } },
+                { provide: valueToken, useValue: { kind: 'second' } },
+            ];
+        });
+
+        itReturnsDuplicatedToken();
+        itReturnsDedupedSingletons();
+    });
+
+    describe('with the same token in singletons and instances', () => {
+        beforeEach(() => {
+            singletons = [StoreA];
+            instances = [StoreA];
+        });
+
+        itReturnsDuplicatedToken();
+
+        test('keeps singletons entry', () => {
+            expect(subject().singletons).toEqual([singletons[0]]);
+        });
+
+        test('drops instances the entry', () => {
+            expect(subject().instances).toEqual([]);
+        });
+    });
+
+    describe('with multiple duplicate tokens', () => {
+        beforeEach(() => (singletons = [StoreA, StoreA, { provide: StoreB }, StoreB]));
+
+        test('returns duplicated tokens', () => {
+            expect(subject().duplicates).toEqual([singletons[1], singletons[3]]);
+        });
+
+        test('returns deduped singletons', () => {
+            expect(subject().singletons).toEqual([singletons[0], singletons[2]]);
+        });
+    });
+
+    describe('when a token appears >2 times', () => {
+        beforeEach(() => (singletons = [StoreA, StoreA, StoreA]));
+
+        test('returns duplicated token once', () => {
+            expect(subject().duplicates).toEqual([singletons[0]]);
+        });
+    });
+});

package/src/__tests__/entry-helpers.test.ts

@@ -0,0 +1,247 @@
+import { symbolToken } from '../common';
+import {
+    formatToken,
+    getProvideToken,
+    getProvideTokenWithClass,
+    isClassProviderConfigEntryToken,
+    isClassProviderConfigEntryUseClass,
+    isProviderConfigEntryInheritable,
+    isValueProviderConfigEntry,
+} from '../entry-helpers';
+
+class StoreA {}
+class StoreB {}
+
+function itReturns(subject: () => boolean, value: boolean) {
+    test(`returns ${value}`, () => {
+        expect(subject()).toBe(value);
+    });
+}
+
+describe('[react-ioc] formatToken', () => {
+    let token: any;
+
+    const subject = () => formatToken(token);
+
+    describe('with a named class', () => {
+        beforeEach(() => (token = StoreA));
+
+        test('returns class name', () => {
+            expect(subject()).toBe(token.name);
+        });
+    });
+
+    describe('with unnamed class', () => {
+        beforeEach(() => (token = (() => class {})()));
+
+        test('returns (anonymous)', () => {
+            expect(subject()).toBe('(anonymous)');
+        });
+    });
+
+    describe('with a symbol token', () => {
+        beforeEach(() => (token = symbolToken('test/symbol-token')));
+
+        test('returns symbol description', () => {
+            expect(subject()).toEqual(token.description);
+        });
+
+        describe('when symbol has no description', () => {
+            beforeEach(() => (token = Symbol()));
+
+            test('returns token.toString()', () => {
+                expect(subject()).toEqual(token.toString());
+            });
+        });
+    });
+});
+
+describe('[react-ioc] getProvideToken', () => {
+    let entry: any;
+
+    const subject = () => getProvideToken(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        test('returns the class', () => {
+            expect(subject()).toBe(entry);
+        });
+    });
+
+    describe('with a provide entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        function itReturnsEntryProvide() {
+            test('returns entry.provide', () => {
+                expect(subject()).toBe(entry.provide);
+            });
+        }
+
+        itReturnsEntryProvide();
+
+        describe('with useClass', () => {
+            beforeEach(() => (entry.useClass = StoreB));
+
+            itReturnsEntryProvide();
+        });
+
+        describe('with useValue', () => {
+            beforeEach(() => (entry.useValue = { kind: 'first' }));
+
+            itReturnsEntryProvide();
+        });
+
+        describe('with inherit: true', () => {
+            beforeEach(() => (entry.inherit = true));
+
+            itReturnsEntryProvide();
+        });
+    });
+});
+
+describe('[react-ioc] getProvideTokenWithClass', () => {
+    let entry: any;
+
+    const subject = () => getProvideTokenWithClass(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        test('returns [class, class]', () => {
+            expect(subject()).toEqual([entry, entry]);
+        });
+    });
+
+    describe('with a provide entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        test('returns [entry.provide, entry.provide]', () => {
+            expect(subject()).toEqual([entry.provide, entry.provide]);
+        });
+
+        describe('with useClass', () => {
+            beforeEach(() => (entry.useClass = StoreB));
+
+            test('returns [entry.provide, entry.useClass]', () => {
+                expect(subject()).toEqual([entry.provide, entry.useClass]);
+            });
+        });
+
+        describe('with useValue', () => {
+            beforeEach(() => (entry.useValue = { kind: 'first' }));
+
+            test('returns [undefined, undefined]', () => {
+                expect(subject()).toEqual([undefined, undefined]);
+            });
+        });
+    });
+});
+
+describe('[react-ioc] isClassProviderConfigEntryToken', () => {
+    let entry: any;
+
+    const subject = () => isClassProviderConfigEntryToken(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        itReturns(subject, false);
+    });
+
+    describe('with a provide entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        itReturns(subject, true);
+
+        describe('with useClass', () => {
+            beforeEach(() => (entry.useClass = StoreB));
+
+            itReturns(subject, false);
+        });
+
+        describe('with useValue', () => {
+            beforeEach(() => (entry.useValue = { kind: 'first' }));
+
+            itReturns(subject, false);
+        });
+    });
+});
+
+describe('[react-ioc] isClassProviderConfigEntryUseClass', () => {
+    let entry: any;
+
+    const subject = () => isClassProviderConfigEntryUseClass(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        itReturns(subject, false);
+    });
+
+    describe('with a provide-only entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        itReturns(subject, false);
+
+        describe('with a useClass entry', () => {
+            beforeEach(() => (entry.useClass = StoreB));
+
+            itReturns(subject, true);
+        });
+    });
+});
+
+describe('[react-ioc] isProviderConfigEntryInheritable', () => {
+    let entry: any;
+
+    const subject = () => isProviderConfigEntryInheritable(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        itReturns(subject, false);
+    });
+
+    describe('with a provide entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        itReturns(subject, true);
+
+        describe('with useClass', () => {
+            beforeEach(() => (entry.useClass = StoreB));
+
+            itReturns(subject, true);
+        });
+
+        describe('with useValue', () => {
+            beforeEach(() => (entry.useValue = { kind: 'first' }));
+
+            itReturns(subject, true);
+        });
+    });
+});
+
+describe('[react-ioc] isValueProviderConfigEntry', () => {
+    let entry: any;
+
+    const subject = () => isValueProviderConfigEntry(entry);
+
+    describe('with a bare class entry', () => {
+        beforeEach(() => (entry = StoreA));
+
+        itReturns(subject, false);
+    });
+
+    describe('with a provide entry', () => {
+        beforeEach(() => (entry = { provide: StoreA }));
+
+        itReturns(subject, false);
+
+        describe('with a useValue entry', () => {
+            beforeEach(() => (entry.useValue = { kind: 'first' }));
+
+            itReturns(subject, true);
+        });
+    });
+});

package/src/__tests__/provider.test.tsx

@@ -386,4 +386,77 @@ describe('[react-ioc] Provider', () => {
             expect(stat.testDispose).not.toHaveBeenCalled();
         });
     });
+
+    describe('duplicates handling', () => {
+        const originalNodeEnv = process.env.NODE_ENV;
+        const childContent = 'foo';
+        const errorFallback = 'Oops!';
+        let singletons: ProviderProps['singletons'];
+        let instances: ProviderProps['instances'];
+        let warnSpy: jest.SpyInstance;
+
+        beforeAll(() => jest.useFakeTimers());
+        afterAll(() => jest.useRealTimers());
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            singletons = undefined;
+            instances = undefined;
+        });
+
+        afterEach(() => {
+            process.env.NODE_ENV = originalNodeEnv;
+        });
+
+        const subject = () =>
+            render(
+                <Provider
+                    singletons={singletons}
+                    instances={instances}
+                    errorFallback={<div>{errorFallback}</div>}
+                >
+                    <div>{childContent}</div>
+                </Provider>
+            );
+
+        describe('with a duplicate singleton', () => {
+            beforeEach(() => {
+                singletons = [StoreSimple, StoreSimple];
+            });
+
+            test('renders error fallback', async () => {
+                subject();
+
+                await jest.runAllTimersAsync().catch(() => {});
+                expect(screen.getByText(errorFallback)).toBeInTheDocument();
+            });
+
+            test('throws error', async () => {
+                subject();
+
+                await expect(() => jest.runAllTimersAsync()).rejects.toThrow(
+                    /listed more than once/
+                );
+            });
+
+            describe('when in production', () => {
+                beforeEach(() => (process.env.NODE_ENV = 'production'));
+
+                test('logs warning', () => {
+                    subject();
+
+                    expect(warnSpy).toHaveBeenCalledWith(
+                        expect.stringMatching(/listed more than once/)
+                    );
+                });
+
+                test('renders children', () => {
+                    subject();
+
+                    expect(screen.getByText(childContent)).toBeInTheDocument();
+                });
+            });
+        });
+    });
 });

package/src/dedupe-entries.ts

@@ -0,0 +1,50 @@
+import { Token } from './common';
+import {
+    getProvideToken,
+    ProviderConfigEntries,
+    ProviderConfigEntry,
+    ProviderConfigEntryInstances,
+    ProviderConfigEntrySingletons,
+} from './entry-helpers';
+
+export interface DedupeEntriesResult {
+    duplicates: Token<any>[];
+    singletons: ProviderConfigEntrySingletons<any>[];
+    instances: ProviderConfigEntryInstances<any>[];
+}
+
+export function dedupeEntries({
+    singletons = [],
+    instances = [],
+}: ProviderConfigEntries): DedupeEntriesResult {
+    const seen = new Set<Token<any>>();
+    const duplicates: Token<any>[] = [];
+    const dedupedSingletons: ProviderConfigEntrySingletons<any>[] = [];
+    const dedupedInstances: ProviderConfigEntryInstances<any>[] = [];
+
+    function isDuplicate(entry: ProviderConfigEntry<any>): boolean {
+        const token = getProvideToken(entry);
+        if (!seen.has(token)) {
+            seen.add(token);
+            return false;
+        }
+        if (!duplicates.includes(token)) {
+            duplicates.push(token);
+        }
+        return true;
+    }
+
+    for (const entry of singletons) {
+        if (!isDuplicate(entry)) {
+            dedupedSingletons.push(entry);
+        }
+    }
+
+    for (const entry of instances) {
+        if (!isDuplicate(entry)) {
+            dedupedInstances.push(entry);
+        }
+    }
+
+    return { duplicates, singletons: dedupedSingletons, instances: dedupedInstances };
+}

package/src/entry-helpers.ts

@@ -0,0 +1,113 @@
+import { interfaces } from 'inversify';
+import { SymbolToken, Token } from './common';
+
+export type ProviderConfigEntrySingletons<T> =
+    | ClassProviderConfigEntry<T>
+    | ValueProviderConfigEntry<T>;
+export type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;
+export type ProviderConfigEntry<T> =
+    | ProviderConfigEntrySingletons<T>
+    | ProviderConfigEntryInstances<T>;
+
+export interface ProviderConfigEntries {
+    singletons?: ProviderConfigEntrySingletons<any>[];
+    instances?: ProviderConfigEntryInstances<any>[];
+}
+
+export type ClassProviderConfigEntry<T> =
+    | interfaces.Newable<T>
+    | ClassProviderConfigEntryUseClass<T>
+    | ClassProviderConfigEntryToken<T>;
+
+export type ClassProviderConfigEntryNoInherit<T> =
+    | interfaces.Newable<T>
+    | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;
+
+export interface ClassProviderConfigEntryUseClass<T> {
+    provide: Token<T>;
+    useClass: interfaces.Newable<T>;
+    inherit?: true;
+}
+
+export interface ClassProviderConfigEntryToken<T> {
+    provide: interfaces.Newable<T>;
+    inherit?: true;
+}
+
+export interface ValueProviderConfigEntry<T> {
+    provide: SymbolToken<T> | Function;
+    useValue: T;
+    inherit?: true;
+}
+
+export function formatToken(token: Token<unknown>): string {
+    if (typeof token === 'symbol') {
+        return token.description ?? token.toString();
+    }
+    const name = (token as Function).name;
+    return name && name.length > 0 ? name : '(anonymous)';
+}
+
+export function getProvideToken<T>(entry: ProviderConfigEntry<T>): Token<T> {
+    if (
+        isClassProviderConfigEntryUseClass(entry) ||
+        isClassProviderConfigEntryToken(entry) ||
+        isValueProviderConfigEntry(entry)
+    ) {
+        return entry.provide;
+    }
+    return entry;
+}
+
+export function getProvideTokenWithClass<T>(
+    entry: ProviderConfigEntry<T>
+): [Token<T>, interfaces.Newable<T>] | [undefined, undefined] {
+    if (isClassProviderConfigEntryUseClass(entry)) {
+        return [entry.provide, entry.useClass];
+    }
+
+    if (isClassProviderConfigEntryToken(entry)) {
+        return [entry.provide, entry.provide];
+    }
+
+    if (isValueProviderConfigEntry(entry)) {
+        return [undefined, undefined];
+    }
+
+    return [entry, entry];
+}
+
+export function isClassProviderConfigEntryToken<T>(
+    entry: ProviderConfigEntry<T>
+): entry is Omit<ClassProviderConfigEntryToken<T>, 'inherit'> {
+    return (
+        Object.hasOwn(entry, 'provide') &&
+        !Object.hasOwn(entry, 'useClass') &&
+        !Object.hasOwn(entry, 'useValue')
+    );
+}
+
+export function isClassProviderConfigEntryUseClass<T>(
+    entry: ProviderConfigEntry<T>
+): entry is Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'> {
+    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');
+}
+
+export function isProviderConfigEntryInheritable<T>(
+    entry: ProviderConfigEntry<T>
+): entry is
+    | ClassProviderConfigEntryUseClass<T>
+    | ClassProviderConfigEntryToken<T>
+    | ValueProviderConfigEntry<T> {
+    return (
+        isClassProviderConfigEntryUseClass(entry) ||
+        isClassProviderConfigEntryToken(entry) ||
+        isValueProviderConfigEntry(entry)
+    );
+}
+
+export function isValueProviderConfigEntry<T>(
+    entry: ProviderConfigEntry<T>
+): entry is Omit<ValueProviderConfigEntry<T>, 'inherit'> {
+    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');
+}

package/src/provide.tsx

@@ -1,5 +1,6 @@
 import { ComponentType, ReactInstance, ReactNode } from 'react';
-import { Provider, ProviderConfigEntryInstances, ProviderConfigEntrySingletons } from './provider';
+import { ProviderConfigEntries } from './entry-helpers';
+import { Provider } from './provider';
 
 export interface WrappedComponent<P> {
     wrappedComponent: ComponentType<P>;
@@ -12,10 +13,7 @@ export interface FallbackOptions {
 }
 
 export type ProvideDecorator = (
-    stores: {
-        singletons?: ProviderConfigEntrySingletons<any>[];
-        instances?: ProviderConfigEntryInstances<any>[];
-    },
+    stores: ProviderConfigEntries,
     options?: ReactNode | FallbackOptions
 ) => <T extends ComponentType<any>>(target: T) => T & WrappedComponent<T>;
 

package/src/provider.tsx

@@ -1,100 +1,24 @@
-import { Container, interfaces } from 'inversify';
+import { Container } from 'inversify';
 import { FC, PropsWithChildren, ReactNode, useContext, useEffect, useState } from 'react';
 import { Await } from './await';
-import { ContainerContext, SymbolToken, Token } from './common';
+import { ContainerContext, Token } from './common';
+import { dedupeEntries } from './dedupe-entries';
+import {
+    formatToken,
+    getProvideTokenWithClass,
+    isClassProviderConfigEntryToken,
+    isClassProviderConfigEntryUseClass,
+    isProviderConfigEntryInheritable,
+    isValueProviderConfigEntry,
+    ProviderConfigEntries,
+    ProviderConfigEntry,
+} from './entry-helpers';
 import { defaultErrorFallback, defaultLoadingFallback } from './fallbacks';
 import { isStore, Store } from './store';
 
-export type ProviderConfigEntrySingletons<T> =
-    | ClassProviderConfigEntry<T>
-    | ValueProviderConfigEntry<T>;
-export type ProviderConfigEntryInstances<T> = ClassProviderConfigEntryNoInherit<T>;
-export type ProviderConfigEntry<T> =
-    | ProviderConfigEntrySingletons<T>
-    | ProviderConfigEntryInstances<T>;
-
-type ClassProviderConfigEntry<T> =
-    | interfaces.Newable<T>
-    | ClassProviderConfigEntryUseClass<T>
-    | ClassProviderConfigEntryToken<T>;
-
-type ClassProviderConfigEntryNoInherit<T> =
-    | interfaces.Newable<T>
-    | Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'>;
-
-interface ClassProviderConfigEntryUseClass<T> {
-    provide: Token<T>;
-    useClass: interfaces.Newable<T>;
-    inherit?: true;
-}
-
-interface ClassProviderConfigEntryToken<T> {
-    provide: interfaces.Newable<T>;
-    inherit?: true;
-}
-
-interface ValueProviderConfigEntry<T> {
-    provide: SymbolToken<T> | Function;
-    useValue: T;
-    inherit?: true;
-}
-
-function isClassProviderConfigEntryUseClass<T>(
-    entry: ProviderConfigEntry<T>
-): entry is Omit<ClassProviderConfigEntryUseClass<T>, 'inherit'> {
-    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useClass');
-}
-
-function isValueProviderConfigEntry<T>(
-    entry: ProviderConfigEntry<T>
-): entry is Omit<ValueProviderConfigEntry<T>, 'inherit'> {
-    return Object.hasOwn(entry, 'provide') && Object.hasOwn(entry, 'useValue');
-}
-
-function isClassProviderConfigEntryToken<T>(
-    entry: ProviderConfigEntry<T>
-): entry is Omit<ClassProviderConfigEntryToken<T>, 'inherit'> {
-    return (
-        Object.hasOwn(entry, 'provide') &&
-        !Object.hasOwn(entry, 'useClass') &&
-        !Object.hasOwn(entry, 'useValue')
-    );
-}
-
-function isProviderConfigEntryInheritable<T>(
-    entry: ProviderConfigEntry<T>
-): entry is
-    | ClassProviderConfigEntryUseClass<T>
-    | ClassProviderConfigEntryToken<T>
-    | ValueProviderConfigEntry<T> {
-    return (
-        isClassProviderConfigEntryUseClass(entry) ||
-        isClassProviderConfigEntryToken(entry) ||
-        isValueProviderConfigEntry(entry)
-    );
-}
-
-function getProvideTokenWithClass<T>(
-    entry: ProviderConfigEntry<T>
-): [Token<T>, interfaces.Newable<T>] | [undefined, undefined] {
-    if (isClassProviderConfigEntryUseClass(entry)) {
-        return [entry.provide, entry.useClass];
-    }
-
-    if (isClassProviderConfigEntryToken(entry)) {
-        return [entry.provide, entry.provide];
-    }
-
-    if (isValueProviderConfigEntry(entry)) {
-        return [undefined, undefined];
-    }
-
-    return [entry, entry];
-}
-
 function getStoreInstances(
     container: Container,
-    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>
+    { singletons = [], instances = [] }: ProviderConfigEntries
 ): Store[] {
     return [...singletons, ...instances].reduce((out, entry) => {
         const [provide, useClass] = getProvideTokenWithClass(entry);
@@ -151,7 +75,7 @@ const unbindEntry = (container: Container) => (entry: ProviderConfigEntry<any>)
 
 function bindEntries(
     container: Container,
-    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>
+    { singletons = [], instances = [] }: ProviderConfigEntries
 ) {
     singletons.map(bindEntry(container, true)).forEach(binding => {
         binding?.inSingletonScope();
@@ -161,7 +85,7 @@ function bindEntries(
 
 function unbindEntries(
     container: Container,
-    { singletons = [], instances = [] }: Pick<ProviderProps, 'singletons' | 'instances'>
+    { singletons = [], instances = [] }: ProviderConfigEntries
 ) {
     [...singletons, ...instances].forEach(unbindEntry(container));
 }
@@ -192,12 +116,17 @@ function disposeStores(stores: Store[]) {
     }
 }
 
-export type ProviderProps = PropsWithChildren<{
-    singletons?: ProviderConfigEntrySingletons<any>[];
-    instances?: ProviderConfigEntryInstances<any>[];
-    loadingFallback?: ReactNode;
-    errorFallback?: ReactNode;
-}>;
+function formatDuplicatesMessage(duplicates: Token<any>[]): string {
+    const names = duplicates.map(formatToken).join(', ');
+    return `Provider: token listed more than once: ${names}. Remove the duplicate entries.`;
+}
+
+export type ProviderProps = PropsWithChildren<
+    ProviderConfigEntries & {
+        loadingFallback?: ReactNode;
+        errorFallback?: ReactNode;
+    }
+>;
 
 export const Provider: FC<ProviderProps> = ({
     singletons,
@@ -224,17 +153,29 @@ export const Provider: FC<ProviderProps> = ({
             });
         };
 
-        bindEntries(container, { singletons, instances });
-        const promises = initializeStores(
-            getStoreInstances(container, { singletons, instances }),
-            handleError
-        );
+        const config = dedupeEntries({ singletons, instances });
+
+        if (config.duplicates.length > 0) {
+            const message = formatDuplicatesMessage(config.duplicates);
+            if (process.env.NODE_ENV !== 'production') {
+                handleError(new Error(message));
+                return () => {
+                    setContainer(undefined);
+                    setPromises([]);
+                };
+            }
+            // eslint-disable-next-line no-console
+            console.warn(message);
+        }
+
+        bindEntries(container, config);
+        const promises = initializeStores(getStoreInstances(container, config), handleError);
         setPromises(promises);
 
         return () => {
-            const storeInstances = getStoreInstances(container, { singletons, instances });
+            const storeInstances = getStoreInstances(container, config);
 
-            unbindEntries(container, { singletons, instances });
+            unbindEntries(container, config);
             disposeStores(storeInstances);
             setContainer(undefined);
             setPromises([]);