fix: export FlagSource enum as runtime value

[talissoncosta]

Export FlagSource enum from all entry points to make it usable as both a type and runtime value in consumer code.

Previously, FlagSource was only exported as a type declaration, which prevented users from comparing against enum values like FlagSource.NONE in their code. Users had to use workarounds with string literals and type assertions.

Changes:

• Export enum from flagsmith-core.ts
• Re-export from types.d.ts referencing the real enum
• Add FlagSource export to all entry points:
  • index.ts (web browser)
  • isomorphic.ts (SSR/universal)
  • index.react-native.ts (React Native)
  • next-middleware.ts (Next.js edge)

Users can now use:
import { FlagSource } from 'flagsmith';
if (loadingState.source === FlagSource.NONE) { ... }

Why Re-export from Each Entry Point?

Each entry point file (index.ts, isomorphic.ts, index.react-native.ts, next-middleware.ts) creates a separate JavaScript bundle via Rollup. Users import from different paths depending on their environment:

// These resolve to DIFFERENT bundles:
import { FlagSource } from 'flagsmith';            // → lib/flagsmith/index.js
import { FlagSource } from 'flagsmith/isomorphic'; // → lib/flagsmith/isomorphic.js
import { FlagSource } from 'flagsmith/react-native'; // → lib/react-native-flagsmith/index.js

The Problem Without Re-exports

When Rollup bundles each entry point, it only exports what that specific entry file explicitly exports:

// isomorphic.ts (without re-export)
import core from './flagsmith-core';
export default core({ ... });
// ❌ FlagSource is bundled but NOT exported

// Built file: lib/flagsmith/isomorphic.js
exports.default = flagsmith;
// FlagSource code exists in bundle but isn't exposed ❌

Result: SSR users would get an error:

import { FlagSource } from 'flagsmith/isomorphic';
//       ^^^^^^^^^^^ Error: Module has no exported member 'FlagSource'

The Solution: Explicit Re-exports

By adding export { FlagSource } from './flagsmith-core' to each entry point, the bundled files properly expose it:

// isomorphic.ts (with re-export)
import core from './flagsmith-core';
export default core({ ... });
export { FlagSource } from './flagsmith-core'; ✅

// Built file: lib/flagsmith/isomorphic.js
exports.default = flagsmith;
exports.FlagSource = { NONE: "NONE", ... }; ✅

Result: All users can access FlagSource regardless of which entry point they use.

[talissoncosta]

@Zaimwa9

I was considering adding those tests:

import { FlagSource } from '../index';
import { FlagSource as FlagSourceIso } from '../isomorphic';

describe('FlagSource Export', () => {

    test('should export FlagSource enum with all values', () => {
        expect(FlagSource).toBeDefined();
        expect(FlagSource.NONE).toBe('NONE');
        expect(FlagSource.DEFAULT_FLAGS).toBe('DEFAULT_FLAGS');
        expect(FlagSource.CACHE).toBe('CACHE');
        expect(FlagSource.SERVER).toBe('SERVER');
    });

    test('should be usable in runtime value comparisons', () => {
        const source = 'NONE' as string;

        expect(source === FlagSource.NONE).toBe(true);
        expect(source === FlagSource.CACHE).toBe(false);

        const mySource: FlagSource = FlagSource.NONE;
        expect(mySource).toBe('NONE');
    });

    test('should export FlagSource from all entry points', () => {
        expect(FlagSourceIso).toBeDefined();
        expect(FlagSourceIso.NONE).toBe('NONE');
        expect(FlagSource.NONE).toBe(FlagSourceIso.NONE);
    });
});

What do you think about it ?

[Zaimwa9]

Lgtm! Thanks