@toggld/browser 0.0.0-stage → 0.1.0

package/dist/effect.d.ts

@@ -0,0 +1,43 @@
+import { a as ToggldClientOptions, c as FlagMetadata, i as EvaluationDetails, l as FlagValue, n as ClientSnapshot, o as ErrorCode, r as ClientStatus, s as EvaluationContext, t as ToggldClient$1, u as Reason } from "./client-BQFClvyL.js";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
+/** The client's surface as effects. Every effect is non-failing. */
+export interface ToggldClientShape {
+  /**
+   * The underlying Promise client, for code that is not Effect, for example
+   * `<ToggldProvider client={…}>` from `@toggld/react`.
+   */
+  readonly client: ToggldClient$1;
+  /** Completes once the first values arrive, or a failure makes that impossible. */
+  readonly ready: Effect.Effect<void>;
+  /** Fetch fresh values for the current context now. */
+  readonly refresh: Effect.Effect<void>;
+  /** Evaluate for a new context (replaced, not merged). Completes when the request settles. */
+  readonly setContext: (context: EvaluationContext) => Effect.Effect<void>;
+  /** The current state. */
+  readonly snapshot: Effect.Effect<ClientSnapshot>;
+  /** The current state, then every change to it, until the stream is interrupted. */
+  readonly changes: Stream.Stream<ClientSnapshot>;
+  readonly evaluate: (key: string, defaultValue: FlagValue) => Effect.Effect<EvaluationDetails<FlagValue>>;
+  readonly allFlags: Effect.Effect<ReadonlyArray<EvaluationDetails<FlagValue>>>;
+  readonly getBooleanValue: (key: string, defaultValue: boolean) => Effect.Effect<boolean>;
+  readonly getBooleanDetails: (key: string, defaultValue: boolean) => Effect.Effect<EvaluationDetails<boolean>>;
+  readonly getStringValue: (key: string, defaultValue: string) => Effect.Effect<string>;
+  readonly getStringDetails: (key: string, defaultValue: string) => Effect.Effect<EvaluationDetails<string>>;
+  readonly getNumberValue: (key: string, defaultValue: number) => Effect.Effect<number>;
+  readonly getNumberDetails: (key: string, defaultValue: number) => Effect.Effect<EvaluationDetails<number>>;
+  readonly getObjectValue: <T extends FlagValue>(key: string, defaultValue: T) => Effect.Effect<T>;
+  readonly getObjectDetails: <T extends FlagValue>(key: string, defaultValue: T) => Effect.Effect<EvaluationDetails<T>>;
+}
+declare const ToggldClient_base: Context.ServiceClass<ToggldClient, "@toggld/browser/ToggldClient", ToggldClientShape>;
+/** The Toggld browser client as an Effect service. */
+export declare class ToggldClient extends ToggldClient_base {}
+/** Wrap an existing Promise client. Closing it stays the caller's job. */
+export declare const fromClient: (client: ToggldClient$1) => ToggldClientShape;
+/** Create a client owned by the current scope: it closes when the scope does. */
+export declare const make: (options: ToggldClientOptions) => Effect.Effect<ToggldClientShape, never, Scope.Scope>;
+/**
+ * A layer that provides {@link ToggldClient}. It starts loading at once but
+ * does not wait for values; `yield* flags.ready` to wait.
+ */
+export declare const layer: (options: ToggldClientOptions) => Layer.Layer<ToggldClient>;
+export type { ClientSnapshot, ClientStatus, ErrorCode, EvaluationContext, EvaluationDetails, FlagMetadata, FlagValue, Reason, ToggldClientOptions };

package/dist/effect.js

@@ -0,0 +1,62 @@
+import { t as ToggldClient$1 } from "./client-BwTN-sJD.js";
+import { Context, Effect, Layer, Queue, Stream } from "effect";
+// src/effect.ts
+/**
+* `@toggld/browser/effect` — the native Effect API. Needs the optional `effect`
+* peer dependency (`^4.0.5`); the default `@toggld/browser` entry does not.
+*
+* The client as a scoped service: build a {@link layer} from your options and
+* `yield* ToggldClient`. The layer's scope owns the client and closes it.
+*
+* ```ts
+* import { Effect, Stream } from "effect"
+* import { ToggldClient, layer } from "@toggld/browser/effect"
+*
+* const program = Effect.gen(function* () {
+*   const flags = yield* ToggldClient
+*   yield* flags.ready
+*   const on = yield* flags.getBooleanValue("new-checkout", false)
+*   // Every state change, starting with the current state:
+*   yield* flags.changes.pipe(Stream.runForEach((s) => Effect.log(s.status)))
+* })
+*
+* program.pipe(Effect.provide(layer({ publicToken, context })), Effect.runFork)
+* ```
+*
+* This is a thin wrapper over the dependency-free client in
+* `./internal/client.ts`, which is the implementation of both entries.
+*/
+/** The Toggld browser client as an Effect service. */
+var ToggldClient = class extends Context.Service()("@toggld/browser/ToggldClient") {};
+/** Wrap an existing Promise client. Closing it stays the caller's job. */
+const fromClient = (client) => ({
+	client,
+	ready: Effect.promise(() => client.ready()),
+	refresh: Effect.promise(() => client.refresh()),
+	setContext: (context) => Effect.promise(() => client.setContext(context)),
+	snapshot: Effect.sync(() => client.getSnapshot()),
+	changes: Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		Queue.offerUnsafe(queue, client.getSnapshot());
+		return client.subscribe(() => {
+			Queue.offerUnsafe(queue, client.getSnapshot());
+		});
+	}), (unsubscribe) => Effect.sync(unsubscribe))),
+	evaluate: (key, defaultValue) => Effect.sync(() => client.evaluate(key, defaultValue)),
+	allFlags: Effect.sync(() => client.allFlags()),
+	getBooleanValue: (key, defaultValue) => Effect.sync(() => client.getBooleanValue(key, defaultValue)),
+	getBooleanDetails: (key, defaultValue) => Effect.sync(() => client.getBooleanDetails(key, defaultValue)),
+	getStringValue: (key, defaultValue) => Effect.sync(() => client.getStringValue(key, defaultValue)),
+	getStringDetails: (key, defaultValue) => Effect.sync(() => client.getStringDetails(key, defaultValue)),
+	getNumberValue: (key, defaultValue) => Effect.sync(() => client.getNumberValue(key, defaultValue)),
+	getNumberDetails: (key, defaultValue) => Effect.sync(() => client.getNumberDetails(key, defaultValue)),
+	getObjectValue: (key, defaultValue) => Effect.sync(() => client.getObjectValue(key, defaultValue)),
+	getObjectDetails: (key, defaultValue) => Effect.sync(() => client.getObjectDetails(key, defaultValue))
+});
+/** Create a client owned by the current scope: it closes when the scope does. */
+const make = (options) => Effect.acquireRelease(Effect.sync(() => new ToggldClient$1(options)), (client) => Effect.sync(() => client.close())).pipe(Effect.map(fromClient));
+/**
+* A layer that provides {@link ToggldClient}. It starts loading at once but
+* does not wait for values; `yield* flags.ready` to wait.
+*/
+const layer = (options) => Layer.effect(ToggldClient, make(options));
+export { ToggldClient, fromClient, layer, make };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { a as ToggldClientOptions, c as FlagMetadata, i as EvaluationDetails, l as FlagValue, n as ClientSnapshot, o as ErrorCode, r as ClientStatus, s as EvaluationContext, t as ToggldClient, u as Reason } from "./client-BQFClvyL.js";
+export { type ClientSnapshot, type ClientStatus, type ErrorCode, type EvaluationContext, type EvaluationDetails, type FlagMetadata, type FlagValue, type Reason, ToggldClient, type ToggldClientOptions };

package/dist/index.js

@@ -0,0 +1 @@
+export { t as ToggldClient } from "./client-BwTN-sJD.js";

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@toggld/browser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Toggld SDK for browsers — evaluates every flag for the current user in one request and serves values synchronously from memory. Zero dependencies; optional native Effect API via @toggld/browser/effect.",
+  "license": "Apache-2.0",
+  "homepage": "https://toggld.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toggld/toggld.git",
+    "directory": "packages/browser"
+  },
+  "bugs": {
+    "url": "https://github.com/toggld/toggld/issues"
+  },
+  "keywords": [
+    "feature-flags",
+    "openfeature",
+    "ofrep",
+    "toggld",
+    "browser",
+    "effect"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./effect": {
+      "types": "./dist/effect.d.ts",
+      "default": "./dist/effect.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.5"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "effect": "4.0.6",
+    "tsdown": "^0.23.2",
+    "typescript": "6.0.3",
+    "@toggld/server": "0.1.0",
+    "@toggld/spec": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "size": "tsdown && node scripts/check-size.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
 }