@zitadel/sdk-angular 0.1.0-alpha.0 → 0.1.0-alpha.11

package/README.md

@@ -2,6 +2,10 @@
 
 Angular components for the Zitadel auth UI, for client-side SPAs.
 
+## Requirements
+
+TypeScript ≥ 5.0 — the published type definitions re-export with `export type *`, which TypeScript introduced in 5.0.
+
 ## Usage
 
 ```ts

package/dist/index.js

@@ -0,0 +1,140 @@
+import * as t from "@angular/core";
+import { EventEmitter as l, ViewChild as u, Output as n, Input as o, CUSTOM_ELEMENTS_SCHEMA as c, Component as d } from "@angular/core";
+import "@zitadel/components";
+const r = class r {
+  constructor() {
+    this.purpose = "login", this.flowStep = new l(), this.flowInput = new l(), this.flowComplete = new l(), this.flowError = new l();
+  }
+  /** The underlying `<zitadel-login>` custom element, or `null` before view init. */
+  get element() {
+    return this.elementRef?.nativeElement ?? null;
+  }
+  onFlowStep(e) {
+    this.flowStep.emit(e.detail);
+  }
+  onFlowInput(e) {
+    this.flowInput.emit(e.detail);
+  }
+  onFlowComplete(e) {
+    this.flowComplete.emit(e.detail);
+  }
+  onFlowError(e) {
+    this.flowError.emit(e.detail);
+  }
+};
+r.ɵfac = t.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: t, type: r, deps: [], target: t.ɵɵFactoryTarget.Component }), r.ɵcmp = t.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.0", type: r, isStandalone: !0, selector: "zitadel-auth-login", inputs: { project: "project", projectId: "projectId", proxyPath: "proxyPath", purpose: "purpose", postSignInUrl: "postSignInUrl" }, outputs: { flowStep: "flowStep", flowInput: "flowInput", flowComplete: "flowComplete", flowError: "flowError" }, viewQueries: [{ propertyName: "elementRef", first: !0, predicate: ["el"], descendants: !0 }], ngImport: t, template: `<zitadel-login
+    #el
+    [project]="project"
+    [projectId]="projectId"
+    [proxyPath]="proxyPath"
+    [attr.purpose]="purpose"
+    [attr.post-sign-in-url]="postSignInUrl"
+    (zitadel-flow-step)="onFlowStep($event)"
+    (zitadel-flow-input)="onFlowInput($event)"
+    (zitadel-flow-complete)="onFlowComplete($event)"
+    (zitadel-flow-error)="onFlowError($event)"
+  ></zitadel-login>`, isInline: !0 });
+let s = r;
+t.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: t, type: s, decorators: [{
+  type: d,
+  args: [{
+    selector: "zitadel-auth-login",
+    standalone: !0,
+    schemas: [c],
+    template: `<zitadel-login
+    #el
+    [project]="project"
+    [projectId]="projectId"
+    [proxyPath]="proxyPath"
+    [attr.purpose]="purpose"
+    [attr.post-sign-in-url]="postSignInUrl"
+    (zitadel-flow-step)="onFlowStep($event)"
+    (zitadel-flow-input)="onFlowInput($event)"
+    (zitadel-flow-complete)="onFlowComplete($event)"
+    (zitadel-flow-error)="onFlowError($event)"
+  ></zitadel-login>`
+  }]
+}], propDecorators: { project: [{
+  type: o
+}], projectId: [{
+  type: o
+}], proxyPath: [{
+  type: o
+}], purpose: [{
+  type: o
+}], postSignInUrl: [{
+  type: o
+}], flowStep: [{
+  type: n
+}], flowInput: [{
+  type: n
+}], flowComplete: [{
+  type: n
+}], flowError: [{
+  type: n
+}], elementRef: [{
+  type: u,
+  args: ["el"]
+}] } });
+const p = class p {
+  constructor() {
+    this.signout = new l();
+  }
+  /** The underlying `<zitadel-logout>` custom element, or `null` before view init. */
+  get element() {
+    return this.elementRef?.nativeElement ?? null;
+  }
+  onSignout(e) {
+    this.signout.emit(e.detail);
+  }
+};
+p.ɵfac = t.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: t, type: p, deps: [], target: t.ɵɵFactoryTarget.Component }), p.ɵcmp = t.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.0", type: p, isStandalone: !0, selector: "zitadel-auth-logout", inputs: { project: "project", projectId: "projectId", proxyPath: "proxyPath", postSignOutUrl: "postSignOutUrl" }, outputs: { signout: "signout" }, viewQueries: [{ propertyName: "elementRef", first: !0, predicate: ["el"], descendants: !0 }], ngImport: t, template: `<zitadel-logout
+    #el
+    [project]="project"
+    [projectId]="projectId"
+    [proxyPath]="proxyPath"
+    [attr.post-sign-out-url]="postSignOutUrl"
+    (zitadel-signout)="onSignout($event)"
+  ></zitadel-logout>`, isInline: !0 });
+let a = p;
+t.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: t, type: a, decorators: [{
+  type: d,
+  args: [{
+    selector: "zitadel-auth-logout",
+    standalone: !0,
+    schemas: [c],
+    template: `<zitadel-logout
+    #el
+    [project]="project"
+    [projectId]="projectId"
+    [proxyPath]="proxyPath"
+    [attr.post-sign-out-url]="postSignOutUrl"
+    (zitadel-signout)="onSignout($event)"
+  ></zitadel-logout>`
+  }]
+}], propDecorators: { project: [{
+  type: o
+}], projectId: [{
+  type: o
+}], proxyPath: [{
+  type: o
+}], postSignOutUrl: [{
+  type: o
+}], signout: [{
+  type: n
+}], elementRef: [{
+  type: u,
+  args: ["el"]
+}] } });
+function w(i) {
+  return Object.freeze({
+    proxyPath: i.proxyPath ?? "/__nextgen",
+    projectId: i.projectId,
+    url: i.url
+  });
+}
+export {
+  s as ZitadelLoginComponent,
+  a as ZitadelLogoutComponent,
+  w as configureZitadel
+};

package/dist/types/lib/config.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SDK configuration for the Angular wrapper.
+ *
+ * `@zitadel/api` is published with subpath-only `exports` and no main entry,
+ * which ng-packagr's module resolution cannot follow. For the client-side SPA
+ * (prop-based) flow the widget only needs a plain handle — `{ projectId,
+ * proxyPath }` — which it reads directly. So this package builds that handle
+ * locally rather than importing `configureZitadel` from `@zitadel/api`, keeping
+ * the Angular library self-contained.
+ */
+/** Frozen project handle passed to the widgets via the `project` input. */
+export interface ZitadelProject {
+    readonly proxyPath: string;
+    readonly projectId: string;
+    readonly url?: string;
+}
+/** Input options for {@link configureZitadel}. */
+export interface ZitadelConfig {
+    /** Proxy path for API requests. Defaults to `"/__nextgen"`. */
+    proxyPath?: string;
+    /** Project id passed to flow creation. */
+    projectId: string;
+    /** Full backend URL (server-side only; optional for client SPAs). */
+    url?: string;
+}
+/**
+ * Builds the project handle to pass to `<zitadel-auth-login [project]>`.
+ *
+ * ```ts
+ * const project = configureZitadel({ projectId: "…", proxyPath: "/__nextgen" });
+ * ```
+ */
+export declare function configureZitadel(config: ZitadelConfig): ZitadelProject;
+//# sourceMappingURL=config.d.ts.map

package/dist/types/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,CAMtE"}

package/dist/types/lib/zitadel-login.component.d.ts

@@ -0,0 +1,48 @@
+import type { ZitadelLogin as ZitadelLoginElement } from "@zitadel/components";
+import type { CreateFlowBodyPurpose, ZitadelFlowCompleteDetail, ZitadelFlowErrorDetail, ZitadelFlowInputDetail, ZitadelFlowStepDetail } from "@zitadel/sdk-core/types";
+import { EventEmitter } from "@angular/core";
+import type { ZitadelProject } from "./config";
+import "@zitadel/components";
+import * as i0 from "@angular/core";
+/**
+ * Angular wrapper for the `<zitadel-login>` Lit web component.
+ *
+ * Uses a distinct selector (`zitadel-auth-login`) and renders the real custom
+ * element in its template under `CUSTOM_ELEMENTS_SCHEMA`. The `project` handle
+ * (from `configureZitadel(...)`) is bound as a DOM **property** via `[project]`,
+ * as are the discrete `projectId` / `proxyPath` the element reads when no handle
+ * is supplied; `purpose` / `post-sign-in-url` are bound as attributes the Lit
+ * element reads. The widget's `zitadel-*` events are re-emitted with their
+ * detail as the `flowStep` / `flowInput` / `flowComplete` / `flowError` outputs.
+ *
+ * The underlying `<zitadel-login>` custom element is exposed via the
+ * {@link element} getter so a consumer holding the component (e.g. via
+ * `@ViewChild(ZitadelLoginComponent)`) can reach the real DOM element — the
+ * Angular analogue of React's `forwardRef`.
+ *
+ * ```html
+ * <zitadel-auth-login [project]="project" purpose="login" postSignInUrl="/"
+ *   (flowComplete)="onComplete($event)" />
+ * ```
+ */
+export declare class ZitadelLoginComponent {
+    project?: ZitadelProject;
+    projectId?: string;
+    proxyPath?: string;
+    purpose: CreateFlowBodyPurpose;
+    postSignInUrl?: string;
+    flowStep: EventEmitter<ZitadelFlowStepDetail>;
+    flowInput: EventEmitter<ZitadelFlowInputDetail>;
+    flowComplete: EventEmitter<ZitadelFlowCompleteDetail>;
+    flowError: EventEmitter<ZitadelFlowErrorDetail>;
+    private elementRef?;
+    /** The underlying `<zitadel-login>` custom element, or `null` before view init. */
+    get element(): ZitadelLoginElement | null;
+    onFlowStep(event: Event): void;
+    onFlowInput(event: Event): void;
+    onFlowComplete(event: Event): void;
+    onFlowError(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZitadelLoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ZitadelLoginComponent, "zitadel-auth-login", never, { "project": { "alias": "project"; "required": false; }; "projectId": { "alias": "projectId"; "required": false; }; "proxyPath": { "alias": "proxyPath"; "required": false; }; "purpose": { "alias": "purpose"; "required": false; }; "postSignInUrl": { "alias": "postSignInUrl"; "required": false; }; }, { "flowStep": "flowStep"; "flowInput": "flowInput"; "flowComplete": "flowComplete"; "flowError": "flowError"; }, never, never, true, never>;
+}
+//# sourceMappingURL=zitadel-login.component.d.ts.map

package/dist/types/lib/zitadel-login.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zitadel-login.component.d.ts","sourceRoot":"","sources":["../../../src/lib/zitadel-login.component.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAGL,YAAY,EAIb,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG/C,OAAO,qBAAqB,CAAC;;AAE7B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAiBa,qBAAqB;IACvB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,qBAAqB,CAAW;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,sCAA6C;IACrD,SAAS,uCAA8C;IACvD,YAAY,0CAAiD;IAC7D,SAAS,uCAA8C;IAEhD,OAAO,CAAC,UAAU,CAAC,CAAkC;IAEtE,mFAAmF;IACnF,IAAI,OAAO,IAAI,mBAAmB,GAAG,IAAI,CAExC;IAED,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAI9B,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAI/B,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAIlC,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;yCA9BpB,qBAAqB;2CAArB,qBAAqB;CAiCjC"}

package/dist/types/lib/zitadel-logout.component.d.ts

@@ -0,0 +1,32 @@
+import type { ZitadelLogout as ZitadelLogoutElement } from "@zitadel/components";
+import type { ZitadelSignoutDetail } from "@zitadel/sdk-core/types";
+import { EventEmitter } from "@angular/core";
+import type { ZitadelProject } from "./config";
+import "@zitadel/components";
+import * as i0 from "@angular/core";
+/**
+ * Angular wrapper for the `<zitadel-logout>` Lit web component. See
+ * {@link ZitadelLoginComponent} for the strategy. The widget's
+ * `zitadel-signout` event is re-emitted with its detail as the `signout`
+ * output. The underlying `<zitadel-logout>` custom element is exposed via the
+ * {@link element} getter (the Angular analogue of React's `forwardRef`).
+ *
+ * ```html
+ * <zitadel-auth-logout [project]="project" postSignOutUrl="/login"
+ *   (signout)="onSignout($event)" />
+ * ```
+ */
+export declare class ZitadelLogoutComponent {
+    project?: ZitadelProject;
+    projectId?: string;
+    proxyPath?: string;
+    postSignOutUrl?: string;
+    signout: EventEmitter<ZitadelSignoutDetail>;
+    private elementRef?;
+    /** The underlying `<zitadel-logout>` custom element, or `null` before view init. */
+    get element(): ZitadelLogoutElement | null;
+    onSignout(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZitadelLogoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ZitadelLogoutComponent, "zitadel-auth-logout", never, { "project": { "alias": "project"; "required": false; }; "projectId": { "alias": "projectId"; "required": false; }; "proxyPath": { "alias": "proxyPath"; "required": false; }; "postSignOutUrl": { "alias": "postSignOutUrl"; "required": false; }; }, { "signout": "signout"; }, never, never, true, never>;
+}
+//# sourceMappingURL=zitadel-logout.component.d.ts.map

package/dist/types/lib/zitadel-logout.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zitadel-logout.component.d.ts","sourceRoot":"","sources":["../../../src/lib/zitadel-logout.component.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,IAAI,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,OAAO,EAGL,YAAY,EAIb,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,qBAAqB,CAAC;;AAE7B;;;;;;;;;;;GAWG;AACH,qBAaa,sBAAsB;IACxB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,qCAA4C;IAE5C,OAAO,CAAC,UAAU,CAAC,CAAmC;IAEvE,oFAAoF;IACpF,IAAI,OAAO,IAAI,oBAAoB,GAAG,IAAI,CAEzC;IAED,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;yCAdlB,sBAAsB;2CAAtB,sBAAsB;CAiBlC"}

package/dist/types/public-api.d.ts

@@ -0,0 +1,6 @@
+export { ZitadelLoginComponent } from "./lib/zitadel-login.component";
+export { ZitadelLogoutComponent } from "./lib/zitadel-logout.component";
+export { configureZitadel } from "./lib/config";
+export type { ZitadelConfig, ZitadelProject } from "./lib/config";
+export type * from "@zitadel/sdk-core/types";
+//# sourceMappingURL=public-api.d.ts.map

package/dist/types/public-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["../../src/public-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGlE,mBAAmB,yBAAyB,CAAC"}

package/dist/types/test-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/types/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../../src/test-setup.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,41 +1,73 @@
 {
   "name": "@zitadel/sdk-angular",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.11",
   "description": "Angular components for the Zitadel auth UI (client-side SPA).",
   "homepage": "https://github.com/zitadel/nextgen/tree/main/packages/sdk-angular#readme",
   "bugs": {
     "url": "https://github.com/zitadel/nextgen/issues"
   },
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zitadel/nextgen.git",
     "directory": "packages/sdk-angular"
   },
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/types/public-api.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/public-api.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "publishConfig": {
-    "access": "public",
-    "directory": "dist"
+    "access": "public"
   },
   "dependencies": {
     "tslib": "^2.6.0",
-    "@zitadel/api": "0.1.0-alpha.0",
-    "@zitadel/components": "0.1.0-alpha.0"
+    "@zitadel/api": "0.1.0-alpha.11",
+    "@zitadel/components": "0.1.0-alpha.11",
+    "@zitadel/sdk-core": "0.1.0-alpha.11"
   },
   "peerDependencies": {
     "@angular/common": ">=17",
     "@angular/core": ">=17"
   },
-  "module": "fesm2022/zitadel-sdk-angular.mjs",
-  "typings": "types/zitadel-sdk-angular.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./types/zitadel-sdk-angular.d.ts",
-      "default": "./fesm2022/zitadel-sdk-angular.mjs"
-    }
+  "devDependencies": {
+    "@analogjs/vite-plugin-angular": "^2.6.1",
+    "@analogjs/vitest-angular": "^2.6.1",
+    "@angular/build": "^22.0.0",
+    "@angular/common": "^22.0.0",
+    "@angular/compiler": "^22.0.0",
+    "@angular/compiler-cli": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/platform-browser": "^22.0.1",
+    "@eslint/js": "^9.0.0",
+    "@eslint/json": "^0.11.0",
+    "@eslint/markdown": "^6.0.0",
+    "@testing-library/angular": "^19.4.1",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-perfectionist": "^4.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "jsdom": "^29.0.2",
+    "prettier": "^3.0.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.0.0",
+    "vite": "^7.3.5",
+    "vitest": "^3.0.0",
+    "zone.js": "~0.16.0"
   },
-  "sideEffects": false,
-  "type": "module"
+  "scripts": {
+    "build": "vite build && ngc -p tsconfig.lib.json",
+    "typecheck": "tsc --noEmit -p tsconfig.spec.json",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
 }

package/fesm2022/zitadel-sdk-angular.mjs

@@ -1,112 +0,0 @@
-import * as i0 from '@angular/core';
-import { Input, CUSTOM_ELEMENTS_SCHEMA, Component } from '@angular/core';
-import '@zitadel/components';
-
-/**
- * Angular wrapper for the `<zitadel-login>` Lit web component.
- *
- * Uses a distinct selector (`zitadel-auth-login`) and renders the real custom
- * element in its template under `CUSTOM_ELEMENTS_SCHEMA`. The `project` handle
- * (from `configureZitadel(...)`) is bound as a DOM **property** via `[project]`;
- * `purpose` / `post-sign-in-url` are bound as attributes the Lit element reads.
- *
- * ```html
- * <zitadel-auth-login [project]="project" purpose="login" postSignInUrl="/" />
- * ```
- */
-class ZitadelLoginComponent {
-    project;
-    purpose = 'login';
-    postSignInUrl;
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: ZitadelLoginComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.0", type: ZitadelLoginComponent, isStandalone: true, selector: "zitadel-auth-login", inputs: { project: "project", purpose: "purpose", postSignInUrl: "postSignInUrl" }, ngImport: i0, template: `<zitadel-login
-    [project]="project"
-    [attr.purpose]="purpose"
-    [attr.post-sign-in-url]="postSignInUrl"
-  ></zitadel-login>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: ZitadelLoginComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'zitadel-auth-login',
-                    standalone: true,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                    template: `<zitadel-login
-    [project]="project"
-    [attr.purpose]="purpose"
-    [attr.post-sign-in-url]="postSignInUrl"
-  ></zitadel-login>`,
-                }]
-        }], propDecorators: { project: [{
-                type: Input
-            }], purpose: [{
-                type: Input
-            }], postSignInUrl: [{
-                type: Input
-            }] } });
-
-/**
- * Angular wrapper for the `<zitadel-logout>` Lit web component. See
- * {@link ZitadelLoginComponent} for the strategy.
- *
- * ```html
- * <zitadel-auth-logout [project]="project" postSignOutUrl="/login" />
- * ```
- */
-class ZitadelLogoutComponent {
-    project;
-    postSignOutUrl;
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: ZitadelLogoutComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.0", type: ZitadelLogoutComponent, isStandalone: true, selector: "zitadel-auth-logout", inputs: { project: "project", postSignOutUrl: "postSignOutUrl" }, ngImport: i0, template: `<zitadel-logout
-    [project]="project"
-    [attr.post-sign-out-url]="postSignOutUrl"
-  ></zitadel-logout>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: ZitadelLogoutComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'zitadel-auth-logout',
-                    standalone: true,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                    template: `<zitadel-logout
-    [project]="project"
-    [attr.post-sign-out-url]="postSignOutUrl"
-  ></zitadel-logout>`,
-                }]
-        }], propDecorators: { project: [{
-                type: Input
-            }], postSignOutUrl: [{
-                type: Input
-            }] } });
-
-/**
- * SDK configuration for the Angular wrapper.
- *
- * `@zitadel/api` is published with subpath-only `exports` and no main entry,
- * which ng-packagr's module resolution cannot follow. For the client-side SPA
- * (prop-based) flow the widget only needs a plain handle — `{ projectId,
- * proxyPath }` — which it reads directly. So this package builds that handle
- * locally rather than importing `configureZitadel` from `@zitadel/api`, keeping
- * the Angular library self-contained.
- */
-/**
- * Builds the project handle to pass to `<zitadel-auth-login [project]>`.
- *
- * ```ts
- * const project = configureZitadel({ projectId: "…", proxyPath: "/__nextgen" });
- * ```
- */
-function configureZitadel(config) {
-    return Object.freeze({
-        proxyPath: config.proxyPath ?? '/__nextgen',
-        projectId: config.projectId,
-        url: config.url,
-    });
-}
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { ZitadelLoginComponent, ZitadelLogoutComponent, configureZitadel };
-//# sourceMappingURL=zitadel-sdk-angular.mjs.map

package/fesm2022/zitadel-sdk-angular.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"zitadel-sdk-angular.mjs","sources":["../../src/lib/zitadel-login.component.ts","../../src/lib/zitadel-logout.component.ts","../../src/lib/config.ts","../../src/zitadel-sdk-angular.ts"],"sourcesContent":["import { Component, Input, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';\n\nimport type { ZitadelProject } from './config';\n\n// Registers <zitadel-login> / <zitadel-logout> with the browser.\nimport '@zitadel/components';\n\n/**\n * Angular wrapper for the `<zitadel-login>` Lit web component.\n *\n * Uses a distinct selector (`zitadel-auth-login`) and renders the real custom\n * element in its template under `CUSTOM_ELEMENTS_SCHEMA`. The `project` handle\n * (from `configureZitadel(...)`) is bound as a DOM **property** via `[project]`;\n * `purpose` / `post-sign-in-url` are bound as attributes the Lit element reads.\n *\n * ```html\n * <zitadel-auth-login [project]=\"project\" purpose=\"login\" postSignInUrl=\"/\" />\n * ```\n */\n@Component({\n  selector: 'zitadel-auth-login',\n  standalone: true,\n  schemas: [CUSTOM_ELEMENTS_SCHEMA],\n  template: `<zitadel-login\n    [project]=\"project\"\n    [attr.purpose]=\"purpose\"\n    [attr.post-sign-in-url]=\"postSignInUrl\"\n  ></zitadel-login>`,\n})\nexport class ZitadelLoginComponent {\n  @Input() project?: ZitadelProject;\n  @Input() purpose = 'login';\n  @Input() postSignInUrl?: string;\n}\n","import { Component, Input, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';\n\nimport type { ZitadelProject } from './config';\n\nimport '@zitadel/components';\n\n/**\n * Angular wrapper for the `<zitadel-logout>` Lit web component. See\n * {@link ZitadelLoginComponent} for the strategy.\n *\n * ```html\n * <zitadel-auth-logout [project]=\"project\" postSignOutUrl=\"/login\" />\n * ```\n */\n@Component({\n  selector: 'zitadel-auth-logout',\n  standalone: true,\n  schemas: [CUSTOM_ELEMENTS_SCHEMA],\n  template: `<zitadel-logout\n    [project]=\"project\"\n    [attr.post-sign-out-url]=\"postSignOutUrl\"\n  ></zitadel-logout>`,\n})\nexport class ZitadelLogoutComponent {\n  @Input() project?: ZitadelProject;\n  @Input() postSignOutUrl?: string;\n}\n","/**\n * SDK configuration for the Angular wrapper.\n *\n * `@zitadel/api` is published with subpath-only `exports` and no main entry,\n * which ng-packagr's module resolution cannot follow. For the client-side SPA\n * (prop-based) flow the widget only needs a plain handle — `{ projectId,\n * proxyPath }` — which it reads directly. So this package builds that handle\n * locally rather than importing `configureZitadel` from `@zitadel/api`, keeping\n * the Angular library self-contained.\n */\n\n/** Frozen project handle passed to the widgets via the `project` input. */\nexport interface ZitadelProject {\n  readonly proxyPath: string;\n  readonly projectId: string;\n  readonly url?: string;\n}\n\n/** Input options for {@link configureZitadel}. */\nexport interface ZitadelConfig {\n  /** Proxy path for API requests. Defaults to `\"/__nextgen\"`. */\n  proxyPath?: string;\n  /** Project id passed to flow creation. */\n  projectId: string;\n  /** Full backend URL (server-side only; optional for client SPAs). */\n  url?: string;\n}\n\n/**\n * Builds the project handle to pass to `<zitadel-auth-login [project]>`.\n *\n * ```ts\n * const project = configureZitadel({ projectId: \"…\", proxyPath: \"/__nextgen\" });\n * ```\n */\nexport function configureZitadel(config: ZitadelConfig): ZitadelProject {\n  return Object.freeze({\n    proxyPath: config.proxyPath ?? '/__nextgen',\n    projectId: config.projectId,\n    url: config.url,\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;AAWG;MAWU,qBAAqB,CAAA;AACvB,IAAA,OAAO;IACP,OAAO,GAAG,OAAO;AACjB,IAAA,aAAa;uGAHX,qBAAqB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA;AAArB,IAAA,OAAA,IAAA,GAAA,EAAA,CAAA,oBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,IAAA,EAAA,qBAAqB,EAAA,YAAA,EAAA,IAAA,EAAA,QAAA,EAAA,oBAAA,EAAA,MAAA,EAAA,EAAA,OAAA,EAAA,SAAA,EAAA,OAAA,EAAA,SAAA,EAAA,aAAA,EAAA,eAAA,EAAA,EAAA,QAAA,EAAA,EAAA,EAAA,QAAA,EANtB,CAAA;;;;AAIQ,mBAAA,CAAA,EAAA,QAAA,EAAA,IAAA,EAAA,CAAA;;2FAEP,qBAAqB,EAAA,UAAA,EAAA,CAAA;kBAVjC,SAAS;AAAC,YAAA,IAAA,EAAA,CAAA;AACT,oBAAA,QAAQ,EAAE,oBAAoB;AAC9B,oBAAA,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,sBAAsB,CAAC;AACjC,oBAAA,QAAQ,EAAE,CAAA;;;;AAIQ,mBAAA,CAAA;AACnB,iBAAA;;sBAEE;;sBACA;;sBACA;;;AC1BH;;;;;;;AAOG;MAUU,sBAAsB,CAAA;AACxB,IAAA,OAAO;AACP,IAAA,cAAc;uGAFZ,sBAAsB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA;AAAtB,IAAA,OAAA,IAAA,GAAA,EAAA,CAAA,oBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,IAAA,EAAA,sBAAsB,EAAA,YAAA,EAAA,IAAA,EAAA,QAAA,EAAA,qBAAA,EAAA,MAAA,EAAA,EAAA,OAAA,EAAA,SAAA,EAAA,cAAA,EAAA,gBAAA,EAAA,EAAA,QAAA,EAAA,EAAA,EAAA,QAAA,EALvB,CAAA;;;AAGS,oBAAA,CAAA,EAAA,QAAA,EAAA,IAAA,EAAA,CAAA;;2FAER,sBAAsB,EAAA,UAAA,EAAA,CAAA;kBATlC,SAAS;AAAC,YAAA,IAAA,EAAA,CAAA;AACT,oBAAA,QAAQ,EAAE,qBAAqB;AAC/B,oBAAA,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,sBAAsB,CAAC;AACjC,oBAAA,QAAQ,EAAE,CAAA;;;AAGS,oBAAA,CAAA;AACpB,iBAAA;;sBAEE;;sBACA;;;ACzBH;;;;;;;;;AASG;AAmBH;;;;;;AAMG;AACG,SAAU,gBAAgB,CAAC,MAAqB,EAAA;IACpD,OAAO,MAAM,CAAC,MAAM,CAAC;AACnB,QAAA,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,YAAY;QAC3C,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,GAAG,EAAE,MAAM,CAAC,GAAG;AAChB,KAAA,CAAC;AACJ;;ACzCA;;AAEG;;;;"}

package/types/zitadel-sdk-angular.d.ts

@@ -1,73 +0,0 @@
-import * as i0 from '@angular/core';
-
-/**
- * SDK configuration for the Angular wrapper.
- *
- * `@zitadel/api` is published with subpath-only `exports` and no main entry,
- * which ng-packagr's module resolution cannot follow. For the client-side SPA
- * (prop-based) flow the widget only needs a plain handle — `{ projectId,
- * proxyPath }` — which it reads directly. So this package builds that handle
- * locally rather than importing `configureZitadel` from `@zitadel/api`, keeping
- * the Angular library self-contained.
- */
-/** Frozen project handle passed to the widgets via the `project` input. */
-interface ZitadelProject {
-    readonly proxyPath: string;
-    readonly projectId: string;
-    readonly url?: string;
-}
-/** Input options for {@link configureZitadel}. */
-interface ZitadelConfig {
-    /** Proxy path for API requests. Defaults to `"/__nextgen"`. */
-    proxyPath?: string;
-    /** Project id passed to flow creation. */
-    projectId: string;
-    /** Full backend URL (server-side only; optional for client SPAs). */
-    url?: string;
-}
-/**
- * Builds the project handle to pass to `<zitadel-auth-login [project]>`.
- *
- * ```ts
- * const project = configureZitadel({ projectId: "…", proxyPath: "/__nextgen" });
- * ```
- */
-declare function configureZitadel(config: ZitadelConfig): ZitadelProject;
-
-/**
- * Angular wrapper for the `<zitadel-login>` Lit web component.
- *
- * Uses a distinct selector (`zitadel-auth-login`) and renders the real custom
- * element in its template under `CUSTOM_ELEMENTS_SCHEMA`. The `project` handle
- * (from `configureZitadel(...)`) is bound as a DOM **property** via `[project]`;
- * `purpose` / `post-sign-in-url` are bound as attributes the Lit element reads.
- *
- * ```html
- * <zitadel-auth-login [project]="project" purpose="login" postSignInUrl="/" />
- * ```
- */
-declare class ZitadelLoginComponent {
-    project?: ZitadelProject;
-    purpose: string;
-    postSignInUrl?: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ZitadelLoginComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ZitadelLoginComponent, "zitadel-auth-login", never, { "project": { "alias": "project"; "required": false; }; "purpose": { "alias": "purpose"; "required": false; }; "postSignInUrl": { "alias": "postSignInUrl"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Angular wrapper for the `<zitadel-logout>` Lit web component. See
- * {@link ZitadelLoginComponent} for the strategy.
- *
- * ```html
- * <zitadel-auth-logout [project]="project" postSignOutUrl="/login" />
- * ```
- */
-declare class ZitadelLogoutComponent {
-    project?: ZitadelProject;
-    postSignOutUrl?: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ZitadelLogoutComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ZitadelLogoutComponent, "zitadel-auth-logout", never, { "project": { "alias": "project"; "required": false; }; "postSignOutUrl": { "alias": "postSignOutUrl"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-export { ZitadelLoginComponent, ZitadelLogoutComponent, configureZitadel };
-export type { ZitadelConfig, ZitadelProject };