@schematichq/schematic-angular 1.4.0

package/README.md

@@ -0,0 +1,334 @@
+# schematic-angular
+
+`schematic-angular` is a client-side Angular library for [Schematic](https://schematichq.com) which provides an injectable service to track events, check flags, and more. `schematic-angular` provides the same capabilities as [schematic-js](https://github.com/schematichq/schematic-js/tree/main/js), for Angular apps.
+
+## Install
+
+```bash
+npm install @schematichq/schematic-angular
+# or
+yarn add @schematichq/schematic-angular
+# or
+pnpm add @schematichq/schematic-angular
+```
+
+## Usage
+
+### Setup with `provideSchematic`
+
+Add `provideSchematic` to your application's providers. This works with both standalone and NgModule-based apps.
+
+**Standalone app (app.config.ts):**
+
+```typescript
+import { ApplicationConfig } from "@angular/core";
+import { provideSchematic } from "@schematichq/schematic-angular";
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideSchematic({ publishableKey: "your-publishable-key" }),
+  ],
+};
+```
+
+**NgModule-based app:**
+
+```typescript
+import { NgModule } from "@angular/core";
+import { provideSchematic } from "@schematichq/schematic-angular";
+
+@NgModule({
+  providers: [
+    provideSchematic({ publishableKey: "your-publishable-key" }),
+  ],
+})
+export class AppModule {}
+```
+
+You can also pass a pre-configured client:
+
+```typescript
+import { Schematic } from "@schematichq/schematic-angular";
+
+const client = new Schematic("your-publishable-key", { useWebSocket: true });
+
+provideSchematic({ client });
+```
+
+### Setting context
+
+To set the user context for events and flag checks, use the `identify` method on `SchematicService`:
+
+```typescript
+import { Component, OnInit, inject } from "@angular/core";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({ selector: "app-root", template: `<router-outlet />` })
+export class AppComponent implements OnInit {
+  private schematic = inject(SchematicService);
+
+  ngOnInit() {
+    this.schematic.identify({
+      keys: { id: "my-user-id" },
+      company: {
+        keys: { id: "my-company-id" },
+        traits: { location: "Atlanta, GA" },
+      },
+    });
+  }
+}
+```
+
+To learn more about identifying companies with the `keys` map, see [key management in Schematic public docs](https://docs.schematichq.com/developer_resources/key_management).
+
+### Tracking usage
+
+Once you've set the context with `identify`, you can track events:
+
+```typescript
+import { Component, inject } from "@angular/core";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({
+  selector: "app-usage",
+  template: `<button (click)="onQuery()">Run Query</button>`,
+})
+export class UsageComponent {
+  private schematic = inject(SchematicService);
+
+  onQuery() {
+    this.schematic.track({ event: "query" });
+  }
+}
+```
+
+If you want to record large numbers of the same event at once, or measure usage in terms of a unit like tokens or memory, you can optionally specify a quantity:
+
+```typescript
+this.schematic.track({ event: "query", quantity: 10 });
+```
+
+### Checking flags
+
+Use `flagValue$` to get an Observable of a flag's boolean value:
+
+**With async pipe:**
+
+```typescript
+import { Component, inject } from "@angular/core";
+import { AsyncPipe } from "@angular/common";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({
+  selector: "app-feature",
+  standalone: true,
+  imports: [AsyncPipe],
+  template: `
+    @if (isFeatureEnabled$ | async) {
+      <app-feature />
+    } @else {
+      <app-fallback />
+    }
+  `,
+})
+export class FeatureComponent {
+  private schematic = inject(SchematicService);
+  isFeatureEnabled$ = this.schematic.flagValue$("my-flag-key");
+}
+```
+
+**With Signals (Angular 16+):**
+
+```typescript
+import { Component, inject } from "@angular/core";
+import { toSignal } from "@angular/core/rxjs-interop";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({
+  selector: "app-feature",
+  standalone: true,
+  template: `
+    @if (isFeatureEnabled()) {
+      <app-feature />
+    } @else {
+      <app-fallback />
+    }
+  `,
+})
+export class FeatureComponent {
+  private schematic = inject(SchematicService);
+  isFeatureEnabled = toSignal(this.schematic.flagValue$("my-flag-key"), {
+    initialValue: false,
+  });
+}
+```
+
+### Checking entitlements
+
+Use `entitlement$` to get an Observable with detailed entitlement data including usage information:
+
+```typescript
+import { Component, inject } from "@angular/core";
+import { AsyncPipe } from "@angular/common";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({
+  selector: "app-entitlement",
+  standalone: true,
+  imports: [AsyncPipe],
+  template: `
+    @if (isPending$ | async) {
+      <app-loader />
+    } @else if (entitlement$ | async; as entitlement) {
+      @if (entitlement.featureUsageExceeded) {
+        <div>
+          You have used all of your usage
+          ({{ entitlement.featureUsage }} / {{ entitlement.featureAllocation }})
+        </div>
+      } @else if (entitlement.value) {
+        <app-feature />
+      } @else {
+        <app-no-access />
+      }
+    }
+  `,
+})
+export class EntitlementComponent {
+  private schematic = inject(SchematicService);
+  isPending$ = this.schematic.isPending$();
+  entitlement$ = this.schematic.entitlement$("my-flag-key");
+}
+```
+
+*Note: `isPending$` checks if entitlement data has been loaded, typically via `identify`. It should be used to wrap flag and entitlement checks, but never the initial call to `identify`.*
+
+### Checking plans
+
+Use `plan$` to get an Observable of the current plan information:
+
+```typescript
+import { Component, inject } from "@angular/core";
+import { AsyncPipe } from "@angular/common";
+import { SchematicService } from "@schematichq/schematic-angular";
+
+@Component({
+  selector: "app-plan",
+  standalone: true,
+  imports: [AsyncPipe],
+  template: `
+    @if (plan$ | async; as plan) {
+      <div>Current plan: {{ plan.name }}</div>
+    } @else {
+      <div>No active subscription</div>
+    }
+  `,
+})
+export class PlanComponent {
+  private schematic = inject(SchematicService);
+  plan$ = this.schematic.plan$();
+}
+```
+
+## API Reference
+
+### `provideSchematic(config)`
+
+Configures the Schematic client for dependency injection. Accepts either a `publishableKey` string or a pre-configured `client` instance, plus any `SchematicOptions`.
+
+### `SchematicService`
+
+Injectable service providing all Schematic functionality:
+
+| Method | Return Type | Description |
+|---|---|---|
+| `getClient()` | `Schematic` | Access the underlying Schematic client |
+| `setContext(ctx)` | `void` | Set the evaluation context (company/user) |
+| `identify(body)` | `void` | Identify a user and/or company |
+| `track(body)` | `void` | Track a usage event |
+| `flagValue$(key, fallback?)` | `Observable<boolean>` | Observe a feature flag's boolean value |
+| `entitlement$(key, fallback?)` | `Observable<CheckFlagReturn>` | Observe detailed entitlement data |
+| `plan$()` | `Observable<CheckPlanReturn \| undefined>` | Observe plan information |
+| `isPending$()` | `Observable<boolean>` | Observe loading state |
+
+### `SCHEMATIC_CLIENT`
+
+`InjectionToken<Schematic>` for direct access to the raw client instance via Angular DI.
+
+## Fallback Behavior
+
+The SDK includes built-in fallback behavior to ensure your application continues to function even when unable to reach Schematic.
+
+### Flag Check Fallbacks
+
+When flag checks cannot reach Schematic, they use fallback values in the following priority order:
+
+1. **Callsite fallback**: provided as the second argument to `flagValue$` or `entitlement$`
+2. **Initialization defaults**: configured via `flagCheckDefaults` or `flagValueDefaults` options in `provideSchematic`
+3. **Default value**: returns `false` if no fallback is configured
+
+```typescript
+// Provide a fallback value at the callsite
+isFeatureEnabled$ = this.schematic.flagValue$("feature-flag", true);
+
+// Or configure defaults at initialization
+provideSchematic({
+  publishableKey: "your-publishable-key",
+  flagValueDefaults: {
+    "feature-flag": true,
+  },
+});
+```
+
+### Event Queueing and Retry
+
+When events (track, identify) cannot be sent due to network issues, they are automatically queued and retried:
+
+- Events are queued in memory (up to 100 events by default, configurable via `maxEventQueueSize`)
+- Failed events are retried with exponential backoff (up to 5 attempts by default, configurable via `maxEventRetries`)
+- Events are automatically flushed when the network connection is restored
+
+### WebSocket Fallback
+
+In WebSocket mode, if the WebSocket connection fails, the SDK will provide the last known value or the configured fallback values as outlined above. The WebSocket will also automatically attempt to re-establish its connection using an exponential backoff.
+
+## Troubleshooting
+
+For debugging and development, Schematic supports two special modes:
+
+### Debug Mode
+
+Enables console logging of all Schematic operations:
+
+```typescript
+provideSchematic({
+  publishableKey: "your-publishable-key",
+  debug: true,
+});
+
+// Or via URL parameter
+// https://yoursite.com/?schematic_debug=true
+```
+
+### Offline Mode
+
+Prevents network requests and returns fallback values for all flag checks:
+
+```typescript
+provideSchematic({
+  publishableKey: "your-publishable-key",
+  offline: true,
+});
+
+// Or via URL parameter
+// https://yoursite.com/?schematic_offline=true
+```
+
+Offline mode automatically enables debug mode to help with troubleshooting.
+
+## License
+
+MIT
+
+## Support
+
+Need help? Please open a GitHub issue or reach out to [support@schematichq.com](mailto:support@schematichq.com) and we'll be happy to assist.

package/fesm2022/schematichq-schematic-angular.mjs

@@ -0,0 +1,158 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, makeEnvironmentProviders, DestroyRef } from '@angular/core';
+import * as SchematicJS from '@schematichq/schematic-js';
+export { RuleType, Schematic, TrialStatus, UsagePeriod } from '@schematichq/schematic-js';
+import { Observable, distinctUntilChanged, shareReplay, finalize } from 'rxjs';
+
+const SCHEMATIC_CLIENT = new InjectionToken("SchematicClient");
+
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((key) => {
+        const valA = a[key];
+        const valB = b[key];
+        if (valA instanceof Date && valB instanceof Date) {
+            return valA.getTime() === valB.getTime();
+        }
+        return valA === valB;
+    });
+}
+class SchematicService {
+    client = inject(SCHEMATIC_CLIENT);
+    flagValueCache = new Map();
+    entitlementCache = new Map();
+    planCache;
+    isPendingCache;
+    getClient() {
+        return this.client;
+    }
+    setContext(context) {
+        this.client.setContext(context);
+    }
+    identify(body) {
+        this.client.identify(body);
+    }
+    track(body) {
+        this.client.track(body);
+    }
+    flagValue$(key, fallback = false) {
+        const cacheKey = `${key}:${fallback}`;
+        let cached = this.flagValueCache.get(cacheKey);
+        if (cached)
+            return cached;
+        cached = new Observable((subscriber) => {
+            const current = this.client.getFlagValue(key);
+            subscriber.next(current ?? fallback);
+            const unsubscribe = this.client.addFlagValueListener(key, () => {
+                const value = this.client.getFlagValue(key);
+                subscriber.next(value ?? fallback);
+            });
+            return () => unsubscribe();
+        }).pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }), finalize(() => this.flagValueCache.delete(cacheKey)));
+        this.flagValueCache.set(cacheKey, cached);
+        return cached;
+    }
+    entitlement$(key, fallback = false) {
+        const cacheKey = `${key}:${fallback}`;
+        let cached = this.entitlementCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const fallbackCheck = {
+            flag: key,
+            reason: "Fallback",
+            value: fallback,
+        };
+        cached = new Observable((subscriber) => {
+            const current = this.client.getFlagCheck(key);
+            subscriber.next(current ?? fallbackCheck);
+            const unsubscribe = this.client.addFlagCheckListener(key, () => {
+                const check = this.client.getFlagCheck(key);
+                subscriber.next(check ?? fallbackCheck);
+            });
+            return () => unsubscribe();
+        }).pipe(distinctUntilChanged(shallowEqual), shareReplay({ bufferSize: 1, refCount: true }), finalize(() => this.entitlementCache.delete(cacheKey)));
+        this.entitlementCache.set(cacheKey, cached);
+        return cached;
+    }
+    plan$() {
+        if (this.planCache)
+            return this.planCache;
+        this.planCache = new Observable((subscriber) => {
+            subscriber.next(this.client.getPlan());
+            const unsubscribe = this.client.addPlanListener(() => {
+                subscriber.next(this.client.getPlan());
+            });
+            return () => unsubscribe();
+        }).pipe(distinctUntilChanged(shallowEqual), shareReplay({ bufferSize: 1, refCount: true }), finalize(() => {
+            this.planCache = undefined;
+        }));
+        return this.planCache;
+    }
+    isPending$() {
+        if (this.isPendingCache)
+            return this.isPendingCache;
+        this.isPendingCache = new Observable((subscriber) => {
+            subscriber.next(this.client.getIsPending());
+            const unsubscribe = this.client.addIsPendingListener(() => {
+                subscriber.next(this.client.getIsPending());
+            });
+            return () => unsubscribe();
+        }).pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }), finalize(() => {
+            this.isPendingCache = undefined;
+        }));
+        return this.isPendingCache;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SchematicService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SchematicService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SchematicService, decorators: [{
+            type: Injectable
+        }] });
+
+const version = "1.4.0";
+
+function provideSchematic(config) {
+    const { client: providedClient, publishableKey, additionalHeaders, ...restOpts } = config;
+    return makeEnvironmentProviders([
+        {
+            provide: SCHEMATIC_CLIENT,
+            useFactory: () => {
+                const isProvidedClient = !!providedClient;
+                const client = isProvidedClient
+                    ? providedClient
+                    : new SchematicJS.Schematic(publishableKey, {
+                        ...restOpts,
+                        useWebSocket: true,
+                        additionalHeaders: {
+                            "X-Schematic-Client-Version": `schematic-angular@${version}`,
+                            ...additionalHeaders,
+                        },
+                    });
+                const destroyRef = inject(DestroyRef);
+                destroyRef.onDestroy(() => {
+                    if (!isProvidedClient) {
+                        client.cleanup().catch((error) => {
+                            console.error("Error during Schematic cleanup:", error);
+                        });
+                    }
+                });
+                return client;
+            },
+        },
+        SchematicService,
+    ]);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SCHEMATIC_CLIENT, SchematicService, provideSchematic };
+//# sourceMappingURL=schematichq-schematic-angular.mjs.map

package/fesm2022/schematichq-schematic-angular.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schematichq-schematic-angular.mjs","sources":["../../src/token.ts","../../src/schematic.service.ts","../../src/version.ts","../../src/provide.ts","../../src/schematichq-schematic-angular.ts"],"sourcesContent":["import { InjectionToken } from \"@angular/core\";\nimport * as SchematicJS from \"@schematichq/schematic-js\";\n\nexport const SCHEMATIC_CLIENT = new InjectionToken<SchematicJS.Schematic>(\n  \"SchematicClient\",\n);\n","import { Injectable, inject } from \"@angular/core\";\nimport * as SchematicJS from \"@schematichq/schematic-js\";\nimport { Observable, distinctUntilChanged, finalize, shareReplay } from \"rxjs\";\nimport { SCHEMATIC_CLIENT } from \"./token\";\n\nfunction shallowEqual<T extends Record<string, unknown>>(\n  a: T | undefined,\n  b: T | undefined,\n): boolean {\n  if (a === b) return true;\n  if (!a || !b) return false;\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n  return keysA.every((key) => {\n    const valA = a[key];\n    const valB = b[key];\n    if (valA instanceof Date && valB instanceof Date) {\n      return valA.getTime() === valB.getTime();\n    }\n    return valA === valB;\n  });\n}\n\n@Injectable()\nexport class SchematicService {\n  private client = inject(SCHEMATIC_CLIENT);\n\n  private flagValueCache = new Map<string, Observable<boolean>>();\n  private entitlementCache = new Map<\n    string,\n    Observable<SchematicJS.CheckFlagReturn>\n  >();\n  private planCache?: Observable<SchematicJS.CheckPlanReturn | undefined>;\n  private isPendingCache?: Observable<boolean>;\n\n  getClient(): SchematicJS.Schematic {\n    return this.client;\n  }\n\n  setContext(context: SchematicJS.SchematicContext): void {\n    this.client.setContext(context);\n  }\n\n  identify(body: SchematicJS.EventBodyIdentify): void {\n    this.client.identify(body);\n  }\n\n  track(body: SchematicJS.EventBodyTrack): void {\n    this.client.track(body);\n  }\n\n  flagValue$(key: string, fallback: boolean = false): Observable<boolean> {\n    const cacheKey = `${key}:${fallback}`;\n    let cached = this.flagValueCache.get(cacheKey);\n    if (cached) return cached;\n\n    cached = new Observable<boolean>((subscriber) => {\n      const current = this.client.getFlagValue(key);\n      subscriber.next(current ?? fallback);\n\n      const unsubscribe = this.client.addFlagValueListener(key, () => {\n        const value = this.client.getFlagValue(key);\n        subscriber.next(value ?? fallback);\n      });\n\n      return () => unsubscribe();\n    }).pipe(\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true }),\n      finalize(() => this.flagValueCache.delete(cacheKey)),\n    );\n\n    this.flagValueCache.set(cacheKey, cached);\n    return cached;\n  }\n\n  entitlement$(\n    key: string,\n    fallback: boolean = false,\n  ): Observable<SchematicJS.CheckFlagReturn> {\n    const cacheKey = `${key}:${fallback}`;\n    let cached = this.entitlementCache.get(cacheKey);\n    if (cached) return cached;\n\n    const fallbackCheck: SchematicJS.CheckFlagReturn = {\n      flag: key,\n      reason: \"Fallback\",\n      value: fallback,\n    };\n\n    cached = new Observable<SchematicJS.CheckFlagReturn>((subscriber) => {\n      const current = this.client.getFlagCheck(key);\n      subscriber.next(current ?? fallbackCheck);\n\n      const unsubscribe = this.client.addFlagCheckListener(key, () => {\n        const check = this.client.getFlagCheck(key);\n        subscriber.next(check ?? fallbackCheck);\n      });\n\n      return () => unsubscribe();\n    }).pipe(\n      distinctUntilChanged(shallowEqual),\n      shareReplay({ bufferSize: 1, refCount: true }),\n      finalize(() => this.entitlementCache.delete(cacheKey)),\n    );\n\n    this.entitlementCache.set(cacheKey, cached);\n    return cached;\n  }\n\n  plan$(): Observable<SchematicJS.CheckPlanReturn | undefined> {\n    if (this.planCache) return this.planCache;\n\n    this.planCache = new Observable<SchematicJS.CheckPlanReturn | undefined>(\n      (subscriber) => {\n        subscriber.next(this.client.getPlan());\n\n        const unsubscribe = this.client.addPlanListener(() => {\n          subscriber.next(this.client.getPlan());\n        });\n\n        return () => unsubscribe();\n      },\n    ).pipe(\n      distinctUntilChanged(shallowEqual),\n      shareReplay({ bufferSize: 1, refCount: true }),\n      finalize(() => {\n        this.planCache = undefined;\n      }),\n    );\n\n    return this.planCache;\n  }\n\n  isPending$(): Observable<boolean> {\n    if (this.isPendingCache) return this.isPendingCache;\n\n    this.isPendingCache = new Observable<boolean>((subscriber) => {\n      subscriber.next(this.client.getIsPending());\n\n      const unsubscribe = this.client.addIsPendingListener(() => {\n        subscriber.next(this.client.getIsPending());\n      });\n\n      return () => unsubscribe();\n    }).pipe(\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true }),\n      finalize(() => {\n        this.isPendingCache = undefined;\n      }),\n    );\n\n    return this.isPendingCache;\n  }\n}\n","export const version = \"1.4.0\";\n","import { DestroyRef, inject, makeEnvironmentProviders } from \"@angular/core\";\nimport * as SchematicJS from \"@schematichq/schematic-js\";\n\nimport { SchematicService } from \"./schematic.service\";\nimport { SCHEMATIC_CLIENT } from \"./token\";\nimport { version } from \"./version\";\n\ntype BaseSchematicConfig = Omit<SchematicJS.SchematicOptions, \"useWebSocket\">;\n\ntype SchematicConfigWithClient = BaseSchematicConfig & {\n  client: SchematicJS.Schematic;\n  publishableKey?: never;\n};\n\ntype SchematicConfigWithKey = BaseSchematicConfig & {\n  client?: never;\n  publishableKey: string;\n};\n\nexport type SchematicConfig =\n  | SchematicConfigWithClient\n  | SchematicConfigWithKey;\n\nexport function provideSchematic(config: SchematicConfig) {\n  const {\n    client: providedClient,\n    publishableKey,\n    additionalHeaders,\n    ...restOpts\n  } = config;\n\n  return makeEnvironmentProviders([\n    {\n      provide: SCHEMATIC_CLIENT,\n      useFactory: () => {\n        const isProvidedClient = !!providedClient;\n\n        const client = isProvidedClient\n          ? providedClient\n          : new SchematicJS.Schematic(publishableKey!, {\n              ...restOpts,\n              useWebSocket: true,\n              additionalHeaders: {\n                \"X-Schematic-Client-Version\": `schematic-angular@${version}`,\n                ...additionalHeaders,\n              },\n            });\n\n        const destroyRef = inject(DestroyRef);\n        destroyRef.onDestroy(() => {\n          if (!isProvidedClient) {\n            client.cleanup().catch((error: unknown) => {\n              console.error(\"Error during Schematic cleanup:\", error);\n            });\n          }\n        });\n\n        return client;\n      },\n    },\n    SchematicService,\n  ]);\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@schematichq/schematic-angular",
+  "version": "1.4.0",
+  "author": "Schematic <engineering@schematichq.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/SchematicHQ/schematic-js.git"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=19.0.0",
+    "rxjs": ">=7.0.0"
+  },
+  "resolutions": {
+    "minimatch": ">=3.1.3"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",
+  "module": "fesm2022/schematichq-schematic-angular.mjs",
+  "typings": "types/schematichq-schematic-angular.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/schematichq-schematic-angular.d.ts",
+      "default": "./fesm2022/schematichq-schematic-angular.mjs"
+    }
+  },
+  "sideEffects": false,
+  "type": "module",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/types/schematichq-schematic-angular.d.ts

@@ -0,0 +1,40 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as SchematicJS from '@schematichq/schematic-js';
+export { CheckFlagReturn, CheckPlanReturn, Event, EventBody, EventBodyIdentify, EventBodyTrack, EventType, Keys, RuleType, Schematic, SchematicContext, SchematicOptions, StoragePersister, Traits, TrialStatus, UsagePeriod } from '@schematichq/schematic-js';
+import { Observable } from 'rxjs';
+
+type BaseSchematicConfig = Omit<SchematicJS.SchematicOptions, "useWebSocket">;
+type SchematicConfigWithClient = BaseSchematicConfig & {
+    client: SchematicJS.Schematic;
+    publishableKey?: never;
+};
+type SchematicConfigWithKey = BaseSchematicConfig & {
+    client?: never;
+    publishableKey: string;
+};
+type SchematicConfig = SchematicConfigWithClient | SchematicConfigWithKey;
+declare function provideSchematic(config: SchematicConfig): i0.EnvironmentProviders;
+
+declare const SCHEMATIC_CLIENT: InjectionToken<SchematicJS.Schematic>;
+
+declare class SchematicService {
+    private client;
+    private flagValueCache;
+    private entitlementCache;
+    private planCache?;
+    private isPendingCache?;
+    getClient(): SchematicJS.Schematic;
+    setContext(context: SchematicJS.SchematicContext): void;
+    identify(body: SchematicJS.EventBodyIdentify): void;
+    track(body: SchematicJS.EventBodyTrack): void;
+    flagValue$(key: string, fallback?: boolean): Observable<boolean>;
+    entitlement$(key: string, fallback?: boolean): Observable<SchematicJS.CheckFlagReturn>;
+    plan$(): Observable<SchematicJS.CheckPlanReturn | undefined>;
+    isPending$(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchematicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchematicService>;
+}
+
+export { SCHEMATIC_CLIENT, SchematicService, provideSchematic };
+export type { SchematicConfig };