@servicetitan/launchdarkly-service 36.3.1 → 36.4.0

package/dist/feature-flag-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flag-store.d.ts","sourceRoot":"","sources":["../src/feature-flag-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAG1D,qBACa,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAE7C,KAAK,EAAE,CAAC,CAAmB;;IAOvC,QAAQ,GAAI,OAAO,CAAC,UAElB;CACL"}
+{"version":3,"file":"feature-flag-store.d.ts","sourceRoot":"","sources":["../src/feature-flag-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAG1D,qBACa,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IASzC,KAAK,EAAE,CAAC,CAAmB;;IAO3C,QAAQ,GAAI,OAAO,CAAC,UAElB;CACL"}

package/dist/feature-flag-store.js

@@ -24,7 +24,13 @@ import { injectable } from '@servicetitan/react-ioc';
 import { action, makeObservable, observable } from 'mobx';
 export class FeatureFlagStore {
     constructor(){
-        // @ts-expect-error because 'LDFlagSet' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint
+        /*
+     * Must stay `.ref` rather than a deep observable. Deep MobX conversion
+     * clones the launchdarkly-react-client-sdk useFlags() proxy via descriptor
+     * enumeration, which severs it: reads then bypass client.variation() and
+     * `flag-used` inspectors never fire. Holding the proxy by reference keeps
+     * reads flowing through it.
+     */ // @ts-expect-error because 'LDFlagSet' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint
         _define_property(this, "flags", {});
         _define_property(this, "setFlags", (flags)=>{
             this.flags = flags;
@@ -33,7 +39,7 @@ export class FeatureFlagStore {
     }
 }
 _ts_decorate([
-    observable,
+    observable.ref,
     _ts_metadata("design:type", typeof T === "undefined" ? Object : T)
 ], FeatureFlagStore.prototype, "flags", void 0);
 _ts_decorate([

package/dist/feature-flag-store.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/feature-flag-store.ts"],"sourcesContent":["import { injectable } from '@servicetitan/react-ioc';\nimport { LDFlagSet } from 'launchdarkly-react-client-sdk';\nimport { action, makeObservable, observable } from 'mobx';\n\n@injectable()\nexport class FeatureFlagStore<T extends LDFlagSet = LDFlagSet> {\n    // @ts-expect-error because 'LDFlagSet' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint\n    @observable flags: T = {} as LDFlagSet;\n\n    constructor() {\n        makeObservable(this);\n    }\n\n    @action\n    setFlags = (flags: T) => {\n        this.flags = flags;\n    };\n}\n"],"names":["injectable","action","makeObservable","observable","FeatureFlagStore","flags","setFlags"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,UAAU,QAAQ,0BAA0B;AAErD,SAASC,MAAM,EAAEC,cAAc,EAAEC,UAAU,QAAQ,OAAO;AAG1D,OAAO,MAAMC;IAIT,aAAc;QAHd,yJAAyJ;QACzJ,uBAAYC,SAAW,CAAC;QAMxB,uBACAC,YAAW,CAACD;YACR,IAAI,CAACA,KAAK,GAAGA;QACjB;QANIH,eAAe,IAAI;IACvB;AAMJ"}
+{"version":3,"sources":["../src/feature-flag-store.ts"],"sourcesContent":["import { injectable } from '@servicetitan/react-ioc';\nimport { LDFlagSet } from 'launchdarkly-react-client-sdk';\nimport { action, makeObservable, observable } from 'mobx';\n\n@injectable()\nexport class FeatureFlagStore<T extends LDFlagSet = LDFlagSet> {\n    /*\n     * Must stay `.ref` rather than a deep observable. Deep MobX conversion\n     * clones the launchdarkly-react-client-sdk useFlags() proxy via descriptor\n     * enumeration, which severs it: reads then bypass client.variation() and\n     * `flag-used` inspectors never fire. Holding the proxy by reference keeps\n     * reads flowing through it.\n     */\n    // @ts-expect-error because 'LDFlagSet' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint\n    @observable.ref flags: T = {} as LDFlagSet;\n\n    constructor() {\n        makeObservable(this);\n    }\n\n    @action\n    setFlags = (flags: T) => {\n        this.flags = flags;\n    };\n}\n"],"names":["injectable","action","makeObservable","observable","FeatureFlagStore","flags","setFlags","ref"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,UAAU,QAAQ,0BAA0B;AAErD,SAASC,MAAM,EAAEC,cAAc,EAAEC,UAAU,QAAQ,OAAO;AAG1D,OAAO,MAAMC;IAWT,aAAc;QAVd;;;;;;KAMC,GACD,yJAAyJ;QACzJ,uBAAgBC,SAAW,CAAC;QAM5B,uBACAC,YAAW,CAACD;YACR,IAAI,CAACA,KAAK,GAAGA;QACjB;QANIH,eAAe,IAAI;IACvB;AAMJ;;eAVgBK"}

package/dist/tests/feature-flag-store.test.js

@@ -13,18 +13,32 @@ describe(`[launchdarkly-service] ${FeatureFlagStore.name}`, ()=>{
                 foo: 'bar'
             };
         });
-        const subject = (...args)=>store.setFlags(...args);
+        const subject = ()=>store.setFlags(flags);
         test('sets flags', ()=>{
-            subject(flags);
+            subject();
             expect(store.flags).toEqual(flags);
         });
-        test('stores copy of flags', ()=>{
-            subject(flags);
-            const originalFlags = {
-                ...flags
-            };
-            flags.baz = 'qux';
-            expect(store.flags).toEqual(originalFlags);
+        test('retains the source reference rather than cloning', ()=>{
+            subject();
+            expect(store.flags).toBe(flags);
+        });
+        describe('when flags are backed by a get-trapping proxy', ()=>{
+            let get;
+            beforeEach(()=>{
+                get = jest.fn((target, key, receiver)=>Reflect.get(target, key, receiver));
+                flags = new Proxy({
+                    foo: 'bar'
+                }, {
+                    get
+                });
+            });
+            test('routes single-key reads through the proxy', ()=>{
+                subject();
+                get.mockClear();
+                const value = store.flags.foo;
+                expect(value).toBe('bar');
+                expect(get).toHaveBeenCalledWith(expect.anything(), 'foo', expect.anything());
+            });
         });
     });
 });

package/dist/tests/feature-flag-store.test.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/tests/feature-flag-store.test.ts"],"sourcesContent":["import { LDFlagSet } from 'launchdarkly-js-client-sdk';\nimport { FeatureFlagStore } from '../feature-flag-store';\n\ndescribe(`[launchdarkly-service] ${FeatureFlagStore.name}`, () => {\n    const subject = () => new FeatureFlagStore();\n\n    test('has no flags initially', () => {\n        expect(subject().flags).toEqual({});\n    });\n\n    describe('setFlags', () => {\n        let store: FeatureFlagStore;\n        let flags: LDFlagSet;\n\n        beforeEach(() => {\n            store = new FeatureFlagStore();\n            flags = { foo: 'bar' };\n        });\n\n        const subject = (...args: Parameters<FeatureFlagStore['setFlags']>) =>\n            store.setFlags(...args);\n\n        test('sets flags', () => {\n            subject(flags);\n\n            expect(store.flags).toEqual(flags);\n        });\n\n        test('stores copy of flags', () => {\n            subject(flags);\n\n            const originalFlags = { ...flags };\n            flags.baz = 'qux';\n\n            expect(store.flags).toEqual(originalFlags);\n        });\n    });\n});\n"],"names":["FeatureFlagStore","describe","name","subject","test","expect","flags","toEqual","store","beforeEach","foo","args","setFlags","originalFlags","baz"],"mappings":"AACA,SAASA,gBAAgB,QAAQ,wBAAwB;AAEzDC,SAAS,CAAC,uBAAuB,EAAED,iBAAiBE,IAAI,EAAE,EAAE;IACxD,MAAMC,UAAU,IAAM,IAAIH;IAE1BI,KAAK,0BAA0B;QAC3BC,OAAOF,UAAUG,KAAK,EAAEC,OAAO,CAAC,CAAC;IACrC;IAEAN,SAAS,YAAY;QACjB,IAAIO;QACJ,IAAIF;QAEJG,WAAW;YACPD,QAAQ,IAAIR;YACZM,QAAQ;gBAAEI,KAAK;YAAM;QACzB;QAEA,MAAMP,UAAU,CAAC,GAAGQ,OAChBH,MAAMI,QAAQ,IAAID;QAEtBP,KAAK,cAAc;YACfD,QAAQG;YAERD,OAAOG,MAAMF,KAAK,EAAEC,OAAO,CAACD;QAChC;QAEAF,KAAK,wBAAwB;YACzBD,QAAQG;YAER,MAAMO,gBAAgB;gBAAE,GAAGP,KAAK;YAAC;YACjCA,MAAMQ,GAAG,GAAG;YAEZT,OAAOG,MAAMF,KAAK,EAAEC,OAAO,CAACM;QAChC;IACJ;AACJ"}
+{"version":3,"sources":["../../src/tests/feature-flag-store.test.ts"],"sourcesContent":["import { LDFlagSet } from 'launchdarkly-js-client-sdk';\nimport { FeatureFlagStore } from '../feature-flag-store';\n\ndescribe(`[launchdarkly-service] ${FeatureFlagStore.name}`, () => {\n    const subject = () => new FeatureFlagStore();\n\n    test('has no flags initially', () => {\n        expect(subject().flags).toEqual({});\n    });\n\n    describe('setFlags', () => {\n        let store: FeatureFlagStore;\n        let flags: LDFlagSet;\n\n        beforeEach(() => {\n            store = new FeatureFlagStore();\n            flags = { foo: 'bar' };\n        });\n\n        const subject = () => store.setFlags(flags);\n\n        test('sets flags', () => {\n            subject();\n\n            expect(store.flags).toEqual(flags);\n        });\n\n        test('retains the source reference rather than cloning', () => {\n            subject();\n\n            expect(store.flags).toBe(flags);\n        });\n\n        describe('when flags are backed by a get-trapping proxy', () => {\n            let get: jest.Mock;\n\n            beforeEach(() => {\n                get = jest.fn((target, key, receiver) => Reflect.get(target, key, receiver));\n                flags = new Proxy({ foo: 'bar' }, { get });\n            });\n\n            test('routes single-key reads through the proxy', () => {\n                subject();\n                get.mockClear();\n\n                const value = store.flags.foo;\n\n                expect(value).toBe('bar');\n                expect(get).toHaveBeenCalledWith(expect.anything(), 'foo', expect.anything());\n            });\n        });\n    });\n});\n"],"names":["FeatureFlagStore","describe","name","subject","test","expect","flags","toEqual","store","beforeEach","foo","setFlags","toBe","get","jest","fn","target","key","receiver","Reflect","Proxy","mockClear","value","toHaveBeenCalledWith","anything"],"mappings":"AACA,SAASA,gBAAgB,QAAQ,wBAAwB;AAEzDC,SAAS,CAAC,uBAAuB,EAAED,iBAAiBE,IAAI,EAAE,EAAE;IACxD,MAAMC,UAAU,IAAM,IAAIH;IAE1BI,KAAK,0BAA0B;QAC3BC,OAAOF,UAAUG,KAAK,EAAEC,OAAO,CAAC,CAAC;IACrC;IAEAN,SAAS,YAAY;QACjB,IAAIO;QACJ,IAAIF;QAEJG,WAAW;YACPD,QAAQ,IAAIR;YACZM,QAAQ;gBAAEI,KAAK;YAAM;QACzB;QAEA,MAAMP,UAAU,IAAMK,MAAMG,QAAQ,CAACL;QAErCF,KAAK,cAAc;YACfD;YAEAE,OAAOG,MAAMF,KAAK,EAAEC,OAAO,CAACD;QAChC;QAEAF,KAAK,oDAAoD;YACrDD;YAEAE,OAAOG,MAAMF,KAAK,EAAEM,IAAI,CAACN;QAC7B;QAEAL,SAAS,iDAAiD;YACtD,IAAIY;YAEJJ,WAAW;gBACPI,MAAMC,KAAKC,EAAE,CAAC,CAACC,QAAQC,KAAKC,WAAaC,QAAQN,GAAG,CAACG,QAAQC,KAAKC;gBAClEZ,QAAQ,IAAIc,MAAM;oBAAEV,KAAK;gBAAM,GAAG;oBAAEG;gBAAI;YAC5C;YAEAT,KAAK,6CAA6C;gBAC9CD;gBACAU,IAAIQ,SAAS;gBAEb,MAAMC,QAAQd,MAAMF,KAAK,CAACI,GAAG;gBAE7BL,OAAOiB,OAAOV,IAAI,CAAC;gBACnBP,OAAOQ,KAAKU,oBAAoB,CAAClB,OAAOmB,QAAQ,IAAI,OAAOnB,OAAOmB,QAAQ;YAC9E;QACJ;IACJ;AACJ"}

package/dist/tests/flag-used-inspectors.test.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom';
+//# sourceMappingURL=flag-used-inspectors.test.d.ts.map

package/dist/tests/flag-used-inspectors.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag-used-inspectors.test.d.ts","sourceRoot":"","sources":["../../src/tests/flag-used-inspectors.test.tsx"],"names":[],"mappings":"AACA,OAAO,2BAA2B,CAAC"}

package/dist/tests/flag-used-inspectors.test.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Provider, useDependencies } from '@servicetitan/react-ioc';
+import '@testing-library/jest-dom';
+import { render, screen } from '@testing-library/react';
+import { observer } from 'mobx-react';
+import { FeatureFlagStore } from '../feature-flag-store';
+import { LDProvider } from '../ld-provider';
+import { LD_SERVICE_TOKEN } from '../types';
+const FLAG_KEY = 'my-flag';
+const CAMEL_KEY = 'myFlag';
+function createFakeClient(flagValues, inspectors) {
+    return {
+        allFlags: ()=>({
+                ...flagValues
+            }),
+        variation: (key, defaultValue)=>{
+            const value = key in flagValues ? flagValues[key] : defaultValue;
+            inspectors.filter((i)=>i.type === 'flag-used').forEach((i)=>i.method(key, {
+                    value
+                }, {
+                    kind: 'user',
+                    key: 'test'
+                }));
+            return value;
+        },
+        waitForInitialization: ()=>Promise.resolve(),
+        on: ()=>{},
+        off: ()=>{}
+    };
+}
+const Reader = observer(()=>{
+    const [{ flags }] = useDependencies(FeatureFlagStore);
+    return /*#__PURE__*/ _jsx("div", {
+        "data-testid": "flag-value",
+        children: String(flags[CAMEL_KEY])
+    });
+});
+describe('[launchdarkly-service] flag-used inspector integration', ()=>{
+    const flagValues = {
+        [FLAG_KEY]: true
+    };
+    let inspectorMethod;
+    let ldService;
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        inspectorMethod = jest.fn();
+        const inspector = {
+            type: 'flag-used',
+            name: 'test-inspector',
+            method: inspectorMethod
+        };
+        ldService = {
+            getClient: ({ options })=>{
+                var _ref;
+                return createFakeClient(flagValues, (_ref = options === null || options === void 0 ? void 0 : options.inspectors) !== null && _ref !== void 0 ? _ref : []);
+            },
+            options: {
+                inspectors: [
+                    inspector
+                ]
+            }
+        };
+    });
+    const subject = ()=>render(/*#__PURE__*/ _jsx(Provider, {
+            singletons: [
+                {
+                    provide: LD_SERVICE_TOKEN,
+                    useValue: ldService
+                }
+            ],
+            children: /*#__PURE__*/ _jsx(LDProvider, {
+                clientSideID: "test",
+                projectName: "test",
+                children: /*#__PURE__*/ _jsx(Reader, {})
+            })
+        }));
+    describe('when a flag is read through FeatureFlagStore', ()=>{
+        beforeEach(async ()=>{
+            subject();
+            // Wait for <Reader> to mount and read flag
+            await screen.findByTestId('flag-value');
+        });
+        test('fires the flag-used inspector', ()=>{
+            expect(inspectorMethod).toHaveBeenCalledWith(FLAG_KEY, expect.objectContaining({
+                value: true
+            }), expect.anything());
+        });
+    });
+});
+
+//# sourceMappingURL=flag-used-inspectors.test.js.map

package/dist/tests/flag-used-inspectors.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tests/flag-used-inspectors.test.tsx"],"sourcesContent":["import { Provider, useDependencies } from '@servicetitan/react-ioc';\nimport '@testing-library/jest-dom';\nimport { render, screen } from '@testing-library/react';\nimport { LDClient, LDInspection } from 'launchdarkly-js-client-sdk';\nimport { observer } from 'mobx-react';\nimport { FC } from 'react';\nimport { FeatureFlagStore } from '../feature-flag-store';\nimport { LDProvider } from '../ld-provider';\nimport { LD_SERVICE_TOKEN, LDService } from '../types';\n\nconst FLAG_KEY = 'my-flag';\nconst CAMEL_KEY = 'myFlag';\n\nfunction createFakeClient(\n    flagValues: Record<string, unknown>,\n    inspectors: LDInspection[]\n): LDClient {\n    return {\n        allFlags: () => ({ ...flagValues }),\n        variation: (key: string, defaultValue: unknown) => {\n            const value = key in flagValues ? flagValues[key] : defaultValue;\n            inspectors\n                .filter(i => i.type === 'flag-used')\n                .forEach(i => i.method!(key, { value }, { kind: 'user', key: 'test' }));\n            return value;\n        },\n        waitForInitialization: () => Promise.resolve(),\n        on: () => {},\n        off: () => {},\n    } as Partial<LDClient> as LDClient;\n}\n\nconst Reader: FC = observer(() => {\n    const [{ flags }] = useDependencies(FeatureFlagStore);\n    return <div data-testid=\"flag-value\">{String(flags[CAMEL_KEY])}</div>;\n});\n\ndescribe('[launchdarkly-service] flag-used inspector integration', () => {\n    const flagValues: Record<string, unknown> = { [FLAG_KEY]: true };\n    let inspectorMethod: jest.Mock;\n    let ldService: LDService;\n\n    beforeEach(() => {\n        jest.clearAllMocks();\n\n        inspectorMethod = jest.fn();\n        const inspector: LDInspection = {\n            type: 'flag-used',\n            name: 'test-inspector',\n            method: inspectorMethod,\n        };\n\n        ldService = {\n            getClient: ({ options }) => createFakeClient(flagValues, options?.inspectors ?? []),\n            options: { inspectors: [inspector] },\n        };\n    });\n\n    const subject = () =>\n        render(\n            <Provider singletons={[{ provide: LD_SERVICE_TOKEN, useValue: ldService }]}>\n                <LDProvider clientSideID=\"test\" projectName=\"test\">\n                    <Reader />\n                </LDProvider>\n            </Provider>\n        );\n\n    describe('when a flag is read through FeatureFlagStore', () => {\n        beforeEach(async () => {\n            subject();\n            // Wait for <Reader> to mount and read flag\n            await screen.findByTestId('flag-value');\n        });\n\n        test('fires the flag-used inspector', () => {\n            expect(inspectorMethod).toHaveBeenCalledWith(\n                FLAG_KEY,\n                expect.objectContaining({ value: true }),\n                expect.anything()\n            );\n        });\n    });\n});\n"],"names":["Provider","useDependencies","render","screen","observer","FeatureFlagStore","LDProvider","LD_SERVICE_TOKEN","FLAG_KEY","CAMEL_KEY","createFakeClient","flagValues","inspectors","allFlags","variation","key","defaultValue","value","filter","i","type","forEach","method","kind","waitForInitialization","Promise","resolve","on","off","Reader","flags","div","data-testid","String","describe","inspectorMethod","ldService","beforeEach","jest","clearAllMocks","fn","inspector","name","getClient","options","subject","singletons","provide","useValue","clientSideID","projectName","findByTestId","test","expect","toHaveBeenCalledWith","objectContaining","anything"],"mappings":";AAAA,SAASA,QAAQ,EAAEC,eAAe,QAAQ,0BAA0B;AACpE,OAAO,4BAA4B;AACnC,SAASC,MAAM,EAAEC,MAAM,QAAQ,yBAAyB;AAExD,SAASC,QAAQ,QAAQ,aAAa;AAEtC,SAASC,gBAAgB,QAAQ,wBAAwB;AACzD,SAASC,UAAU,QAAQ,iBAAiB;AAC5C,SAASC,gBAAgB,QAAmB,WAAW;AAEvD,MAAMC,WAAW;AACjB,MAAMC,YAAY;AAElB,SAASC,iBACLC,UAAmC,EACnCC,UAA0B;IAE1B,OAAO;QACHC,UAAU,IAAO,CAAA;gBAAE,GAAGF,UAAU;YAAC,CAAA;QACjCG,WAAW,CAACC,KAAaC;YACrB,MAAMC,QAAQF,OAAOJ,aAAaA,UAAU,CAACI,IAAI,GAAGC;YACpDJ,WACKM,MAAM,CAACC,CAAAA,IAAKA,EAAEC,IAAI,KAAK,aACvBC,OAAO,CAACF,CAAAA,IAAKA,EAAEG,MAAM,CAAEP,KAAK;oBAAEE;gBAAM,GAAG;oBAAEM,MAAM;oBAAQR,KAAK;gBAAO;YACxE,OAAOE;QACX;QACAO,uBAAuB,IAAMC,QAAQC,OAAO;QAC5CC,IAAI,KAAO;QACXC,KAAK,KAAO;IAChB;AACJ;AAEA,MAAMC,SAAazB,SAAS;IACxB,MAAM,CAAC,EAAE0B,KAAK,EAAE,CAAC,GAAG7B,gBAAgBI;IACpC,qBAAO,KAAC0B;QAAIC,eAAY;kBAAcC,OAAOH,KAAK,CAACrB,UAAU;;AACjE;AAEAyB,SAAS,0DAA0D;IAC/D,MAAMvB,aAAsC;QAAE,CAACH,SAAS,EAAE;IAAK;IAC/D,IAAI2B;IACJ,IAAIC;IAEJC,WAAW;QACPC,KAAKC,aAAa;QAElBJ,kBAAkBG,KAAKE,EAAE;QACzB,MAAMC,YAA0B;YAC5BrB,MAAM;YACNsB,MAAM;YACNpB,QAAQa;QACZ;QAEAC,YAAY;YACRO,WAAW,CAAC,EAAEC,OAAO,EAAE;;uBAAKlC,iBAAiBC,oBAAYiC,oBAAAA,8BAAAA,QAAShC,UAAU,uCAAI,EAAE;;YAClFgC,SAAS;gBAAEhC,YAAY;oBAAC6B;iBAAU;YAAC;QACvC;IACJ;IAEA,MAAMI,UAAU,IACZ3C,qBACI,KAACF;YAAS8C,YAAY;gBAAC;oBAAEC,SAASxC;oBAAkByC,UAAUZ;gBAAU;aAAE;sBACtE,cAAA,KAAC9B;gBAAW2C,cAAa;gBAAOC,aAAY;0BACxC,cAAA,KAACrB;;;IAKjBK,SAAS,gDAAgD;QACrDG,WAAW;YACPQ;YACA,2CAA2C;YAC3C,MAAM1C,OAAOgD,YAAY,CAAC;QAC9B;QAEAC,KAAK,iCAAiC;YAClCC,OAAOlB,iBAAiBmB,oBAAoB,CACxC9C,UACA6C,OAAOE,gBAAgB,CAAC;gBAAEtC,OAAO;YAAK,IACtCoC,OAAOG,QAAQ;QAEvB;IACJ;AACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/launchdarkly-service",
-    "version": "36.3.1",
+    "version": "36.4.0",
     "description": "Service for creating and reusing client connections for LaunchDarkly",
     "homepage": "https://docs.st.dev/docs/frontend/uikit/launchdarkly-service",
     "repository": {
@@ -26,22 +26,22 @@
         "src"
     ],
     "devDependencies": {
-        "@datadog/browser-rum": "^7.1.0",
-        "@servicetitan/log-service": "36.3.1",
-        "@servicetitan/react-ioc": "36.3.1",
+        "@datadog/browser-rum": "^7.2.0",
+        "@servicetitan/log-service": "36.4.0",
+        "@servicetitan/react-ioc": "36.4.0",
         "@testing-library/dom": "^10.4.1",
         "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.2",
         "launchdarkly-js-client-sdk": "3.5.0",
         "launchdarkly-react-client-sdk": "3.6.1",
-        "mobx": "~6.15.3",
-        "mobx-react": "~9.2.1",
+        "mobx": "~6.15.4",
+        "mobx-react": "~9.2.2",
         "react": "~18.3.1"
     },
     "peerDependencies": {
         "@datadog/browser-rum": ">=6.19.0",
-        "@servicetitan/log-service": "36.3.1",
-        "@servicetitan/react-ioc": "36.3.1",
+        "@servicetitan/log-service": "36.4.0",
+        "@servicetitan/react-ioc": "36.4.0",
         "launchdarkly-js-client-sdk": "3.5.0",
         "launchdarkly-react-client-sdk": "3.6.1",
         "mobx": ">= 6.13.5",
@@ -59,5 +59,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "93a049ba1e5cb737afb7bc95c06020736bc61a38"
+    "gitHead": "8beab9ae3a70ce381e8cd53f2de8691640e96c6e"
 }

package/src/feature-flag-store.ts

@@ -4,8 +4,15 @@ import { action, makeObservable, observable } from 'mobx';
 
 @injectable()
 export class FeatureFlagStore<T extends LDFlagSet = LDFlagSet> {
+    /*
+     * Must stay `.ref` rather than a deep observable. Deep MobX conversion
+     * clones the launchdarkly-react-client-sdk useFlags() proxy via descriptor
+     * enumeration, which severs it: reads then bypass client.variation() and
+     * `flag-used` inspectors never fire. Holding the proxy by reference keeps
+     * reads flowing through it.
+     */
     // @ts-expect-error because 'LDFlagSet' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint
-    @observable flags: T = {} as LDFlagSet;
+    @observable.ref flags: T = {} as LDFlagSet;
 
     constructor() {
         makeObservable(this);

package/src/tests/feature-flag-store.test.ts

@@ -17,22 +17,37 @@ describe(`[launchdarkly-service] ${FeatureFlagStore.name}`, () => {
             flags = { foo: 'bar' };
         });
 
-        const subject = (...args: Parameters<FeatureFlagStore['setFlags']>) =>
-            store.setFlags(...args);
+        const subject = () => store.setFlags(flags);
 
         test('sets flags', () => {
-            subject(flags);
+            subject();
 
             expect(store.flags).toEqual(flags);
         });
 
-        test('stores copy of flags', () => {
-            subject(flags);
+        test('retains the source reference rather than cloning', () => {
+            subject();
 
-            const originalFlags = { ...flags };
-            flags.baz = 'qux';
+            expect(store.flags).toBe(flags);
+        });
+
+        describe('when flags are backed by a get-trapping proxy', () => {
+            let get: jest.Mock;
+
+            beforeEach(() => {
+                get = jest.fn((target, key, receiver) => Reflect.get(target, key, receiver));
+                flags = new Proxy({ foo: 'bar' }, { get });
+            });
+
+            test('routes single-key reads through the proxy', () => {
+                subject();
+                get.mockClear();
+
+                const value = store.flags.foo;
 
-            expect(store.flags).toEqual(originalFlags);
+                expect(value).toBe('bar');
+                expect(get).toHaveBeenCalledWith(expect.anything(), 'foo', expect.anything());
+            });
         });
     });
 });

package/src/tests/flag-used-inspectors.test.tsx

@@ -0,0 +1,83 @@
+import { Provider, useDependencies } from '@servicetitan/react-ioc';
+import '@testing-library/jest-dom';
+import { render, screen } from '@testing-library/react';
+import { LDClient, LDInspection } from 'launchdarkly-js-client-sdk';
+import { observer } from 'mobx-react';
+import { FC } from 'react';
+import { FeatureFlagStore } from '../feature-flag-store';
+import { LDProvider } from '../ld-provider';
+import { LD_SERVICE_TOKEN, LDService } from '../types';
+
+const FLAG_KEY = 'my-flag';
+const CAMEL_KEY = 'myFlag';
+
+function createFakeClient(
+    flagValues: Record<string, unknown>,
+    inspectors: LDInspection[]
+): LDClient {
+    return {
+        allFlags: () => ({ ...flagValues }),
+        variation: (key: string, defaultValue: unknown) => {
+            const value = key in flagValues ? flagValues[key] : defaultValue;
+            inspectors
+                .filter(i => i.type === 'flag-used')
+                .forEach(i => i.method!(key, { value }, { kind: 'user', key: 'test' }));
+            return value;
+        },
+        waitForInitialization: () => Promise.resolve(),
+        on: () => {},
+        off: () => {},
+    } as Partial<LDClient> as LDClient;
+}
+
+const Reader: FC = observer(() => {
+    const [{ flags }] = useDependencies(FeatureFlagStore);
+    return <div data-testid="flag-value">{String(flags[CAMEL_KEY])}</div>;
+});
+
+describe('[launchdarkly-service] flag-used inspector integration', () => {
+    const flagValues: Record<string, unknown> = { [FLAG_KEY]: true };
+    let inspectorMethod: jest.Mock;
+    let ldService: LDService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        inspectorMethod = jest.fn();
+        const inspector: LDInspection = {
+            type: 'flag-used',
+            name: 'test-inspector',
+            method: inspectorMethod,
+        };
+
+        ldService = {
+            getClient: ({ options }) => createFakeClient(flagValues, options?.inspectors ?? []),
+            options: { inspectors: [inspector] },
+        };
+    });
+
+    const subject = () =>
+        render(
+            <Provider singletons={[{ provide: LD_SERVICE_TOKEN, useValue: ldService }]}>
+                <LDProvider clientSideID="test" projectName="test">
+                    <Reader />
+                </LDProvider>
+            </Provider>
+        );
+
+    describe('when a flag is read through FeatureFlagStore', () => {
+        beforeEach(async () => {
+            subject();
+            // Wait for <Reader> to mount and read flag
+            await screen.findByTestId('flag-value');
+        });
+
+        test('fires the flag-used inspector', () => {
+            expect(inspectorMethod).toHaveBeenCalledWith(
+                FLAG_KEY,
+                expect.objectContaining({ value: true }),
+                expect.anything()
+            );
+        });
+    });
+});