@steppy/angular 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,6 @@
+Steppy Angular adapter (@steppy/angular)
+Copyright 2026 The Steppy Authors
+
+This package is licensed under the Apache License, Version 2.0 (see LICENSE).
+It bundles no third-party code; the tour overlay it loads comes from the
+@steppy/player peer dependency.

package/README.md

@@ -1,3 +1,129 @@
-# Temporary Holding Version
+# @steppy/angular
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Angular adapter for Steppy's in-app tours: guided popovers over your
+live app, compiled from the same Markdown scenarios your end-to-end tests run.
+The overlay itself is `<steppy-tour-host>` from `@steppy/player/tour`; this
+package mounts it the Angular way.
+
+- `provideSteppyTours({...})`: configuration, in `app.config.ts`.
+- `<steppy-tours />`: the overlay, placed **once** in the app shell.
+- `SteppyTours`: a root service to `start()` / `stop()` / `next()` tours,
+  with `active`, `current` and `lastError` signals and an `events` stream.
+- `steppyTourStart`: a directive that starts a tour on click.
+
+Angular 20–22, zone.js or zoneless, SSR-safe (nothing renders or loads on the
+server). Your app needs no `CUSTOM_ELEMENTS_SCHEMA`.
+
+## Install
+
+```bash
+npm install @steppy/angular @steppy/player
+```
+
+`@steppy/player` is a peer dependency at the same version as the adapter.
+
+To use an unreleased build, build both from a Steppy checkout:
+
+```bash
+npm --prefix packages/player ci
+npm --prefix packages/player run build
+npm --prefix packages/angular ci
+npm --prefix packages/angular run build
+```
+
+Then, in your app, either depend on the folders
+(`"@steppy/player": "file:<checkout>/packages/player"`,
+`"@steppy/angular": "file:<checkout>/packages/angular/dist"`, and
+`"preserveSymlinks": true` in the build options so Angular is not loaded twice),
+or install the tarballs `npm pack` makes from those two folders.
+
+## Use
+
+```ts
+// app.config.ts
+import { inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { TranslateService } from '@ngx-translate/core';
+import { map } from 'rxjs';
+import { provideSteppyTours } from '@steppy/angular';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideRouter(routes),
+    provideSteppyTours({
+      // Written by `steppy tours` (an app-assets target in public/tours).
+      fallbackManifest: 'tours/tours.manifest.json',
+      // Optional: follow your i18n library. Without it the tours follow <html lang>.
+      locale: () => {
+        const translate = inject(TranslateService);
+        return toSignal(translate.onLangChange.pipe(map((e) => e.lang)), { initialValue: translate.getCurrentLang() ?? '' });
+      },
+    }),
+  ],
+};
+```
+
+```ts
+// app.component.ts
+@Component({
+  selector: 'app-root',
+  imports: [RouterOutlet, SteppyToursComponent, SteppyTourStart],
+  template: `
+    <button steppyTourStart="create-invoice">Show me how</button>
+    <router-outlet />
+    <steppy-tours (tourComplete)="onDone($event)" />
+  `,
+})
+export class AppComponent {}
+```
+
+```ts
+// anywhere
+const tours = inject(SteppyTours);
+await tours.start('send-invoice', { params: { invoiceId: 1001 } });
+```
+
+### What the adapter does for you
+
+- **Lazy, browser-only loading.** The overlay module is imported after the
+  first render, and only in the browser.
+- **Router navigation.** A tour that starts away from its entry route
+  navigates with `Router.navigateByUrl`, inside the Angular zone, so the routed
+  view renders in zone.js apps. A guard that refuses or redirects the
+  navigation fails the tour at once (`tour-error`, reason `entry-params`)
+  instead of leaving it waiting for an element that will never render. Set
+  `navigate: 'document'` for full page loads, or pass your own function.
+- **Zones.** The overlay's observers, polls and frames run outside the Angular
+  zone, so they never drive change detection; events, outputs and the router
+  come back inside it.
+- **`start()` from anywhere.** It waits for `<steppy-tours>` to mount and the
+  overlay to load (`readyTimeout`, 10 s by default), the last call wins, and it
+  resolves `false` — never rejects — when a tour cannot start.
+
+Destroying `<steppy-tours>` suspends a running tour rather than dismissing
+it (the overlay keeps its resume record). Call `tours.stop()` first to end it.
+
+Inputs on `<steppy-tours>` override the `provideSteppyTours()` settings:
+`fallbackManifest`, `manifest`, `buildId`, `guideOrigin`, `locale`,
+`targetTimeout`, `baseZIndex`, `disabled`, `strings`, `source`. Outputs:
+`tourStart`, `tourStep`, `tourComplete`, `tourDismiss`, `tourOffpath`,
+`tourError`.
+
+Hash routing (`withHashLocation()`) is not supported by in-app tours.
+
+The full reference — authoring tours, the overlay's options and events,
+remote mode, CSP and Trusted Types — is `docs/tours.md` in the Steppy
+repository.
+
+## Develop
+
+```bash
+npm ci
+npm test        # the zoneless suite, then the zone.js suite (ng test --configuration zone)
+npm run build   # ng-packagr → dist/; publish dist/, never this folder
+```
+
+The overlay is replaced by a fake element in the specs (`src/testing/`), except
+in `real-overlay.spec.ts`. The browser test against a real Angular + PrimeNG
+app is `tests/integration/test_tour_angular_it.py` (the demo is
+`fixtures/tour-demo-angular/`).

package/fesm2022/steppy-angular.mjs

@@ -0,0 +1,490 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, NgZone, PLATFORM_ID, signal, Injectable, computed, isSignal, makeEnvironmentProviders, provideEnvironmentInitializer, isDevMode, input, output, DOCUMENT, ElementRef, afterNextRender, effect, DestroyRef, untracked, ChangeDetectionStrategy, Component, Directive } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { Subject } from 'rxjs';
+import { ROUTES, Router } from '@angular/router';
+
+const STEPPY_TOURS_CONFIG = new InjectionToken('STEPPY_TOURS_CONFIG');
+const DEFAULT_READY_TIMEOUT_MS = 10_000;
+
+const PREFIX$1 = '[steppy-tours]';
+/**
+ * Start and follow in-app tours from anywhere in the app.
+ *
+ * The overlay itself lives in ``<steppy-tours>``, placed once in the app
+ * shell; ``start()`` waits for it to be mounted and loaded (up to
+ * ``readyTimeout``), so a help button can call it during startup. State is
+ * built from the overlay's six events and exposed as signals; on the server
+ * every call is a no-op.
+ */
+class SteppyTours {
+    zone = inject(NgZone);
+    browser = isPlatformBrowser(inject(PLATFORM_ID));
+    /** @internal */
+    ɵconfig = inject(STEPPY_TOURS_CONFIG, { optional: true }) ?? {};
+    /** @internal The configured locale source, resolved once in the root injection context. */
+    ɵlocale = resolveLocale(this.ɵconfig.locale);
+    _active = signal(false, ...(ngDevMode ? [{ debugName: "_active" }] : /* istanbul ignore next */ []));
+    _current = signal(null, ...(ngDevMode ? [{ debugName: "_current" }] : /* istanbul ignore next */ []));
+    _lastError = signal(null, ...(ngDevMode ? [{ debugName: "_lastError" }] : /* istanbul ignore next */ []));
+    _events = new Subject();
+    /** A tour is running (from ``tour-start`` until it completes, is dismissed or fails). */
+    active = this._active.asReadonly();
+    /** The step shown, or ``null`` before the first step and after the end. */
+    current = this._current.asReadonly();
+    /** The last ``tour-error`` since the last start (fatal or not). */
+    lastError = this._lastError.asReadonly();
+    /** Every overlay event, in order, delivered inside the Angular zone. */
+    events = this._events.asObservable();
+    owner = null;
+    host = null;
+    failed = false;
+    waiters = [];
+    seq = 0;
+    /**
+     * Start a tour. Resolves ``true`` once it started, ``false`` when it could
+     * not (a ``tour-error`` says why), when no ``<steppy-tours>`` is mounted
+     * in time, when a later ``start()``/``stop()`` superseded this call, or on
+     * the server. Never rejects.
+     */
+    async start(tourId, options = {}) {
+        if (!this.browser)
+            return false;
+        const seq = ++this.seq;
+        const host = await this.whenReady();
+        if (seq !== this.seq)
+            return false;
+        if (!host) {
+            console.warn(this.failed
+                ? `${PREFIX$1} start("${tourId}"): the tour overlay failed to load`
+                : `${PREFIX$1} start("${tourId}"): no <steppy-tours> is mounted, or the overlay did not load ` +
+                    `within ${this.readyTimeout()} ms. Place <steppy-tours /> once in the app shell.`);
+            return false;
+        }
+        // Outside the zone: the overlay's observers, polls and frames must not
+        // drive change detection.
+        return this.zone.runOutsideAngular(() => host.start(tourId, options));
+    }
+    /** End the running tour (``reason`` is passed to ``tour-dismiss``); also cancels a waiting ``start()``. */
+    stop(reason) {
+        this.seq++;
+        this.flush(null);
+        const host = this.host;
+        if (host)
+            this.zone.runOutsideAngular(() => host.stop(reason));
+    }
+    /** Advance the current step, whatever its kind. */
+    next() {
+        const host = this.host;
+        if (host)
+            this.zone.runOutsideAngular(() => host.next());
+    }
+    // ── Used by <steppy-tours> ──────────────────────────────────────────────
+    /** @internal The first component to mount owns the overlay. */
+    ɵclaim(owner) {
+        if (this.owner !== null && this.owner !== owner)
+            return false;
+        this.owner = owner;
+        return true;
+    }
+    /** @internal The overlay is defined (``host``) or failed to load (``null``). */
+    ɵready(owner, host) {
+        if (this.owner !== owner)
+            return;
+        this.host = host;
+        this.failed = host === null;
+        this.flush(host);
+    }
+    /** @internal The owning component was destroyed. */
+    ɵrelease(owner) {
+        if (this.owner !== owner)
+            return;
+        this.owner = null;
+        this.host = null;
+        this.failed = false;
+        this._active.set(false);
+        this._current.set(null);
+    }
+    /** @internal One overlay event (already inside the zone). */
+    ɵrecord(event) {
+        switch (event.type) {
+            case 'tour-start':
+                this._active.set(true);
+                this._current.set(null);
+                this._lastError.set(null);
+                break;
+            case 'tour-step': {
+                const { tourId, stepId, index, total } = event.detail;
+                this._active.set(true);
+                this._current.set({ tourId, stepId, index, total });
+                break;
+            }
+            case 'tour-complete':
+            case 'tour-dismiss':
+                this._active.set(false);
+                this._current.set(null);
+                break;
+            case 'tour-error':
+                this._lastError.set(event.detail);
+                if (event.detail.fatal) {
+                    this._active.set(false);
+                    this._current.set(null);
+                }
+                break;
+            case 'tour-offpath':
+                break;
+        }
+        this._events.next(event);
+    }
+    // ── Internals ──────────────────────────────────────────────────────────────
+    readyTimeout() {
+        return this.ɵconfig.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
+    }
+    whenReady() {
+        if (this.host)
+            return Promise.resolve(this.host);
+        if (this.failed)
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            let timer;
+            const done = (host) => {
+                clearTimeout(timer);
+                this.waiters = this.waiters.filter((w) => w !== done);
+                resolve(host);
+            };
+            this.waiters.push(done);
+            // Outside the zone: a pending timer would keep a zone.js app from ever
+            // becoming stable while it waits.
+            timer = this.zone.runOutsideAngular(() => setTimeout(() => done(null), this.readyTimeout()));
+        });
+    }
+    flush(host) {
+        for (const waiter of [...this.waiters])
+            waiter(host);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyTours, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyTours, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyTours, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function resolveLocale(source) {
+    if (source === undefined)
+        return computed(() => '');
+    if (typeof source === 'string')
+        return computed(() => source);
+    if (isSignal(source))
+        return computed(() => source() ?? '');
+    const made = source();
+    return typeof made === 'string' ? computed(() => made) : computed(() => made() ?? '');
+}
+
+/**
+ * Configure in-app tours for the app, in ``app.config.ts``:
+ *
+ * ```ts
+ * provideSteppyTours({
+ *   fallbackManifest: 'tours/tours.manifest.json',
+ *   locale: () => {
+ *     const translate = inject(TranslateService);
+ *     return toSignal(translate.onLangChange.pipe(map((e) => e.lang)), { initialValue: translate.getCurrentLang() ?? '' });
+ *   },
+ * })
+ * ```
+ *
+ * Then place ``<steppy-tours />`` once in the app shell.
+ */
+function provideSteppyTours(config = {}) {
+    return makeEnvironmentProviders([
+        { provide: STEPPY_TOURS_CONFIG, useValue: config },
+        provideEnvironmentInitializer(() => {
+            if (isDevMode() && inject(SteppyTours).ɵconfig !== config) {
+                console.warn('[steppy-tours] provideSteppyTours() has no effect here: the tours service is a root ' +
+                    'singleton. Call it in the application providers (app.config.ts), not in a lazy route.');
+            }
+        }),
+    ]);
+}
+
+/**
+ * The ``navigate`` hook the overlay calls to reach a tour's entry route (or a
+ * route linked from step text). Call it in an injection context.
+ *
+ * The overlay calls it from outside the Angular zone; the router — and the
+ * routed view it renders — must run inside it, or a zone.js app never renders
+ * the page the tour waits on. Returns ``null`` for ``'document'``, and when the
+ * app has no routes, so the overlay falls back to a full page load.
+ */
+function createNavigate(option = 'router') {
+    if (option === 'document')
+        return null;
+    const zone = inject(NgZone);
+    let go;
+    if (option === 'router') {
+        if (!inject(ROUTES, { optional: true }))
+            return null;
+        go = routerNavigate(inject(Router));
+    }
+    else {
+        go = option;
+    }
+    // ``async``: a synchronous throw becomes a rejection, which the overlay reports.
+    return (path, ctx) => zone.run(async () => void (await go(path, ctx)));
+}
+/**
+ * Navigate with the router and settle only once the router is where the tour
+ * wants to be. ``navigateByUrl`` resolves ``false`` both for a refused
+ * navigation and for one to the current URL, and ``true`` for one a guard
+ * redirected elsewhere — so the outcome is read from ``router.url``. A
+ * rejection makes the overlay fail the start at once (``entry-params``)
+ * instead of waiting for a target that will never render.
+ */
+function routerNavigate(router) {
+    const pathOf = (url) => router.serializeUrl(router.parseUrl(url)).split(/[?#]/, 1)[0];
+    return async (_path, { appPath }) => {
+        const navigated = await router.navigateByUrl(appPath);
+        if (pathOf(router.url) === pathOf(appPath))
+            return;
+        throw new Error(navigated
+            ? `the router redirected ${appPath} to ${router.url}`
+            : `the router did not navigate to ${appPath} (a guard or another navigation cancelled it)`);
+    };
+}
+
+/**
+ * The seam between the adapter and the tour overlay (``@steppy/player/tour``).
+ *
+ * Everything imported from the overlay at the top of this package is a *type*:
+ * the overlay touches ``HTMLElement`` when its module loads, so its only
+ * runtime reference is the dynamic ``import()`` in ``OVERLAY_LOADER``, which
+ * runs in the browser, after the first render. Tests swap the loader for a fake
+ * element on a tag of their own.
+ *
+ * One literal per line: ``tests/test_angular_adapter_sync.py`` reads the tag and
+ * the event names with regular expressions and compares them with the overlay.
+ */
+const TOUR_HOST_TAG = 'steppy-tour-host';
+const TOUR_EVENT_NAMES = ['tour-start', 'tour-step', 'tour-complete', 'tour-dismiss', 'tour-offpath', 'tour-error'];
+const OVERLAY_LOADER = new InjectionToken('steppy tour overlay', {
+    providedIn: 'root',
+    factory: () => ({ tag: TOUR_HOST_TAG, load: () => import('@steppy/player/tour') }),
+});
+/**
+ * Write the props onto the element — before it is defined as well: the
+ * overlay keeps properties set on the element before its upgrade.
+ */
+function applyProps(el, p) {
+    el.fallbackManifest = p.fallbackManifest;
+    el.manifest = p.manifest;
+    el.buildId = p.buildId;
+    el.guideOrigin = p.guideOrigin;
+    el.locale = p.locale;
+    el.disabled = p.disabled;
+    el.strings = p.strings;
+    el.source = p.source;
+    if (p.targetTimeout !== undefined)
+        el.targetTimeout = p.targetTimeout;
+    if (p.baseZIndex !== undefined)
+        el.baseZIndex = p.baseZIndex;
+}
+
+const PREFIX = '[steppy-tours]';
+/** ``undefined`` stays ``undefined`` (= use the config); anything else is read as a number. */
+function optionalNumber(value) {
+    return value === undefined || value === null || value === '' ? undefined : Number(value);
+}
+/** ``undefined`` stays ``undefined``; a bare attribute (``''``) and ``'true'`` are true. */
+function optionalBoolean(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return value === '' || (value !== false && value !== 'false');
+}
+/**
+ * The in-app tour overlay. Place it **once**, in the app shell:
+ *
+ * ```html
+ * <router-outlet />
+ * <steppy-tours />
+ * ```
+ *
+ * It renders nothing on the server. In the browser it mounts
+ * ``<steppy-tour-host>`` after the first render and loads the overlay
+ * module lazily; every input overrides the matching
+ * ``provideSteppyTours()`` setting. Start tours with the
+ * ``SteppyTours`` service or the ``steppyTourStart`` directive.
+ *
+ * Destroying it suspends a running tour rather than dismissing it: the overlay
+ * keeps its resume record, so a tour survives a shell swap. Call
+ * ``SteppyTours.stop()`` first to end it for good.
+ */
+class SteppyToursComponent {
+    fallbackManifest = input(...(ngDevMode ? [undefined, { debugName: "fallbackManifest" }] : /* istanbul ignore next */ []));
+    manifest = input(...(ngDevMode ? [undefined, { debugName: "manifest" }] : /* istanbul ignore next */ []));
+    buildId = input(...(ngDevMode ? [undefined, { debugName: "buildId" }] : /* istanbul ignore next */ []));
+    guideOrigin = input(...(ngDevMode ? [undefined, { debugName: "guideOrigin" }] : /* istanbul ignore next */ []));
+    /** ``null``/``undefined``: the configured locale source. ``''``: follow ``<html lang>``. */
+    locale = input(...(ngDevMode ? [undefined, { debugName: "locale" }] : /* istanbul ignore next */ []));
+    targetTimeout = input(undefined, { ...(ngDevMode ? { debugName: "targetTimeout" } : /* istanbul ignore next */ {}), transform: optionalNumber });
+    baseZIndex = input(undefined, { ...(ngDevMode ? { debugName: "baseZIndex" } : /* istanbul ignore next */ {}), transform: optionalNumber });
+    disabled = input(undefined, { ...(ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {}), transform: optionalBoolean });
+    strings = input(...(ngDevMode ? [undefined, { debugName: "strings" }] : /* istanbul ignore next */ []));
+    source = input(...(ngDevMode ? [undefined, { debugName: "source" }] : /* istanbul ignore next */ []));
+    tourStart = output();
+    tourStep = output();
+    tourComplete = output();
+    tourDismiss = output();
+    tourOffpath = output();
+    tourError = output();
+    tours = inject(SteppyTours);
+    config = this.tours.ɵconfig;
+    overlay = inject(OVERLAY_LOADER);
+    zone = inject(NgZone);
+    document = inject(DOCUMENT);
+    hostRef = inject(ElementRef);
+    browser = isPlatformBrowser(inject(PLATFORM_ID));
+    navigate = createNavigate(this.config.navigate);
+    el = signal(null, ...(ngDevMode ? [{ debugName: "el" }] : /* istanbul ignore next */ []));
+    outputs = {
+        'tour-start': this.tourStart,
+        'tour-step': this.tourStep,
+        'tour-complete': this.tourComplete,
+        'tour-dismiss': this.tourDismiss,
+        'tour-offpath': this.tourOffpath,
+        'tour-error': this.tourError,
+    };
+    props = computed(() => {
+        const c = this.config;
+        const locale = this.locale();
+        const source = this.source();
+        return {
+            fallbackManifest: this.fallbackManifest() ?? c.fallbackManifest ?? '',
+            manifest: this.manifest() ?? c.manifest ?? '',
+            buildId: this.buildId() ?? c.buildId ?? '',
+            guideOrigin: this.guideOrigin() ?? c.guideOrigin ?? '',
+            locale: locale ?? this.tours.ɵlocale(),
+            disabled: this.disabled() ?? c.disabled ?? false,
+            strings: this.strings() ?? c.strings,
+            source: source !== undefined ? source : (c.source ?? null),
+            targetTimeout: this.targetTimeout() ?? c.targetTimeout,
+            baseZIndex: this.baseZIndex() ?? c.baseZIndex,
+        };
+    }, ...(ngDevMode ? [{ debugName: "props" }] : /* istanbul ignore next */ []));
+    onEvent = (event) => this.zone.run(() => {
+        const record = { type: event.type, detail: event.detail };
+        this.tours.ɵrecord(record);
+        this.outputs[record.type].emit(record.detail);
+    });
+    constructor() {
+        // afterNextRender runs in the browser only, outside the Angular zone.
+        afterNextRender(() => this.mount());
+        effect(() => {
+            const el = this.el();
+            const props = this.props();
+            if (el)
+                this.zone.runOutsideAngular(() => applyProps(el, props));
+        });
+        inject(DestroyRef).onDestroy(() => this.unmount());
+    }
+    mount() {
+        if (!this.browser)
+            return;
+        if (!this.tours.ɵclaim(this)) {
+            console.warn(`${PREFIX} another <steppy-tours> is already mounted; this one does nothing. Mount it once, in the app shell.`);
+            return;
+        }
+        const props = untracked(this.props);
+        if (!props.fallbackManifest && !props.manifest) {
+            console.warn(`${PREFIX} no manifest: set fallbackManifest (or manifest) in provideSteppyTours() or on <steppy-tours>`);
+        }
+        // The element is on the page — with its properties and listeners — before
+        // the overlay module defines it: the overlay keeps properties set before
+        // its upgrade, a resumed tour's tour-start is not missed, and anything that
+        // waits for the element to be defined finds it in the DOM.
+        const el = this.document.createElement(this.overlay.tag);
+        applyProps(el, props);
+        el.navigate = this.navigate;
+        for (const name of TOUR_EVENT_NAMES)
+            el.addEventListener(name, this.onEvent);
+        this.hostRef.nativeElement.appendChild(el);
+        this.el.set(el);
+        this.overlay
+            .load()
+            .then(() => customElements.whenDefined(this.overlay.tag))
+            .then(() => {
+            if (this.el() === el)
+                this.tours.ɵready(this, el);
+        }, (err) => {
+            if (this.el() !== el)
+                return;
+            console.error(`${PREFIX} the tour overlay failed to load`, err);
+            this.tours.ɵready(this, null);
+        });
+    }
+    unmount() {
+        const el = untracked(this.el);
+        if (el) {
+            for (const name of TOUR_EVENT_NAMES)
+                el.removeEventListener(name, this.onEvent);
+            el.remove();
+            this.el.set(null);
+        }
+        this.tours.ɵrelease(this);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyToursComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.25", type: SteppyToursComponent, isStandalone: true, selector: "steppy-tours", inputs: { fallbackManifest: { classPropertyName: "fallbackManifest", publicName: "fallbackManifest", isSignal: true, isRequired: false, transformFunction: null }, manifest: { classPropertyName: "manifest", publicName: "manifest", isSignal: true, isRequired: false, transformFunction: null }, buildId: { classPropertyName: "buildId", publicName: "buildId", isSignal: true, isRequired: false, transformFunction: null }, guideOrigin: { classPropertyName: "guideOrigin", publicName: "guideOrigin", isSignal: true, isRequired: false, transformFunction: null }, locale: { classPropertyName: "locale", publicName: "locale", isSignal: true, isRequired: false, transformFunction: null }, targetTimeout: { classPropertyName: "targetTimeout", publicName: "targetTimeout", isSignal: true, isRequired: false, transformFunction: null }, baseZIndex: { classPropertyName: "baseZIndex", publicName: "baseZIndex", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, strings: { classPropertyName: "strings", publicName: "strings", isSignal: true, isRequired: false, transformFunction: null }, source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { tourStart: "tourStart", tourStep: "tourStep", tourComplete: "tourComplete", tourDismiss: "tourDismiss", tourOffpath: "tourOffpath", tourError: "tourError" }, host: { styleAttribute: "display: contents" }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyToursComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'steppy-tours',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents' },
+                }]
+        }], ctorParameters: () => [], propDecorators: { fallbackManifest: [{ type: i0.Input, args: [{ isSignal: true, alias: "fallbackManifest", required: false }] }], manifest: [{ type: i0.Input, args: [{ isSignal: true, alias: "manifest", required: false }] }], buildId: [{ type: i0.Input, args: [{ isSignal: true, alias: "buildId", required: false }] }], guideOrigin: [{ type: i0.Input, args: [{ isSignal: true, alias: "guideOrigin", required: false }] }], locale: [{ type: i0.Input, args: [{ isSignal: true, alias: "locale", required: false }] }], targetTimeout: [{ type: i0.Input, args: [{ isSignal: true, alias: "targetTimeout", required: false }] }], baseZIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "baseZIndex", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], strings: [{ type: i0.Input, args: [{ isSignal: true, alias: "strings", required: false }] }], source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: false }] }], tourStart: [{ type: i0.Output, args: ["tourStart"] }], tourStep: [{ type: i0.Output, args: ["tourStep"] }], tourComplete: [{ type: i0.Output, args: ["tourComplete"] }], tourDismiss: [{ type: i0.Output, args: ["tourDismiss"] }], tourOffpath: [{ type: i0.Output, args: ["tourOffpath"] }], tourError: [{ type: i0.Output, args: ["tourError"] }] } });
+
+/**
+ * Start a tour on click:
+ *
+ * ```html
+ * <button steppyTourStart="create-invoice">Show me how</button>
+ * <button [steppyTourStart]="'send-invoice'" [steppyTourParams]="{ invoiceId: id }">Help</button>
+ * ```
+ */
+class SteppyTourStart {
+    steppyTourStart = input.required(...(ngDevMode ? [{ debugName: "steppyTourStart" }] : /* istanbul ignore next */ []));
+    steppyTourParams = input(...(ngDevMode ? [undefined, { debugName: "steppyTourParams" }] : /* istanbul ignore next */ []));
+    steppyTourStep = input(...(ngDevMode ? [undefined, { debugName: "steppyTourStep" }] : /* istanbul ignore next */ []));
+    tours = inject(SteppyTours);
+    onClick() {
+        const options = {};
+        const params = this.steppyTourParams();
+        const step = this.steppyTourStep();
+        if (params)
+            options.params = params;
+        if (step)
+            options.step = step;
+        void this.tours.start(this.steppyTourStart(), options);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyTourStart, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.25", type: SteppyTourStart, isStandalone: true, selector: "[steppyTourStart]", inputs: { steppyTourStart: { classPropertyName: "steppyTourStart", publicName: "steppyTourStart", isSignal: true, isRequired: true, transformFunction: null }, steppyTourParams: { classPropertyName: "steppyTourParams", publicName: "steppyTourParams", isSignal: true, isRequired: false, transformFunction: null }, steppyTourStep: { classPropertyName: "steppyTourStep", publicName: "steppyTourStep", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: SteppyTourStart, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[steppyTourStart]',
+                    host: { '(click)': 'onClick()' },
+                }]
+        }], propDecorators: { steppyTourStart: [{ type: i0.Input, args: [{ isSignal: true, alias: "steppyTourStart", required: true }] }], steppyTourParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "steppyTourParams", required: false }] }], steppyTourStep: [{ type: i0.Input, args: [{ isSignal: true, alias: "steppyTourStep", required: false }] }] } });
+
+/*
+ * @steppy/angular — the Angular adapter for the Steppy in-app tour overlay.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SteppyTourStart, SteppyTours, SteppyToursComponent, provideSteppyTours, routerNavigate };
+//# sourceMappingURL=steppy-angular.mjs.map

package/fesm2022/steppy-angular.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"steppy-angular.mjs","sources":["../../src/config.ts","../../src/tours.service.ts","../../src/provide.ts","../../src/navigate.ts","../../src/overlay.ts","../../src/tours.component.ts","../../src/tour-start.directive.ts","../../src/public-api.ts","../../src/steppy-angular.ts"],"sourcesContent":["import { InjectionToken, type Signal } from '@angular/core';\nimport type { TourNavigate, TourSource, TourStringOverrides } from '@steppy/player/tour';\n\n/**\n * Where the tours' language comes from. A string or a signal is used as is; a\n * function is called once, in the root injection context, so it may\n * ``inject()`` the app's i18n service and return a signal of its language.\n * ``null``, ``undefined`` and ``''`` all mean \"follow ``<html lang>``\".\n */\nexport type SteppyLocaleSource =\n  | string\n  | Signal<string | null | undefined>\n  | (() => string | Signal<string | null | undefined>);\n\n/** How a tour changes route; ``(path, {appPath, tourId}) => …`` for your own. */\nexport type SteppyNavigate = TourNavigate;\n\nexport interface SteppyToursConfig {\n  /** The tour manifest bundled with the app (same origin), e.g. ``tours/tours.manifest.json``. */\n  fallbackManifest?: string;\n  /** A remote manifest URL; may contain ``{buildId}``. */\n  manifest?: string;\n  /** The app's build id, for ``{buildId}``. Default: the bundled manifest's. */\n  buildId?: string;\n  /** The origin trusted for guide links. Default: the bundled manifest's. */\n  guideOrigin?: string;\n  /** Milliseconds to wait for a step's element (500–120000). Default: the overlay's 8000. */\n  targetTimeout?: number;\n  /** Stacking where the top layer is unavailable. Default: the overlay's. */\n  baseZIndex?: number;\n  /** Turns tours off; stops a running one. */\n  disabled?: boolean;\n  /** Chrome string overrides per locale (buttons, hints). */\n  strings?: TourStringOverrides;\n  /** Supply tour files yourself; see the overlay's ``source`` property. */\n  source?: TourSource | null;\n  /** The tours' language. Default: ``<html lang>``. */\n  locale?: SteppyLocaleSource;\n  /**\n   * ``'router'`` (default): the Angular router, inside the zone; a refused or\n   * redirected navigation fails the tour at once. ``'document'``: a full page\n   * load. Or a function of your own.\n   */\n  navigate?: 'router' | 'document' | SteppyNavigate;\n  /** How long ``start()`` waits for ``<steppy-tours>`` and the overlay to load. Default 10000 ms. */\n  readyTimeout?: number;\n}\n\nexport const STEPPY_TOURS_CONFIG = new InjectionToken<SteppyToursConfig>('STEPPY_TOURS_CONFIG');\n\nexport const DEFAULT_READY_TIMEOUT_MS = 10_000;\n","import { Injectable, NgZone, PLATFORM_ID, computed, inject, isSignal, signal, type Signal } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { Observable, Subject } from 'rxjs';\nimport type { TourErrorDetail, TourEventDetailMap, TourPosition, TourStartOptions } from '@steppy/player/tour';\n\nimport { DEFAULT_READY_TIMEOUT_MS, STEPPY_TOURS_CONFIG, type SteppyLocaleSource, type SteppyToursConfig } from './config';\nimport type { TourHostElement } from './overlay';\n\n/** One overlay event, as the service and the component outputs see it. */\nexport type SteppyTourEvent = {\n  [K in keyof TourEventDetailMap]: { type: K; detail: TourEventDetailMap[K] };\n}[keyof TourEventDetailMap];\n\nconst PREFIX = '[steppy-tours]';\n\n/**\n * Start and follow in-app tours from anywhere in the app.\n *\n * The overlay itself lives in ``<steppy-tours>``, placed once in the app\n * shell; ``start()`` waits for it to be mounted and loaded (up to\n * ``readyTimeout``), so a help button can call it during startup. State is\n * built from the overlay's six events and exposed as signals; on the server\n * every call is a no-op.\n */\n@Injectable({ providedIn: 'root' })\nexport class SteppyTours {\n  private readonly zone = inject(NgZone);\n  private readonly browser = isPlatformBrowser(inject(PLATFORM_ID));\n\n  /** @internal */\n  readonly ɵconfig: SteppyToursConfig = inject(STEPPY_TOURS_CONFIG, { optional: true }) ?? {};\n  /** @internal The configured locale source, resolved once in the root injection context. */\n  readonly ɵlocale: Signal<string> = resolveLocale(this.ɵconfig.locale);\n\n  private readonly _active = signal(false);\n  private readonly _current = signal<TourPosition | null>(null);\n  private readonly _lastError = signal<TourErrorDetail | null>(null);\n  private readonly _events = new Subject<SteppyTourEvent>();\n\n  /** A tour is running (from ``tour-start`` until it completes, is dismissed or fails). */\n  readonly active: Signal<boolean> = this._active.asReadonly();\n  /** The step shown, or ``null`` before the first step and after the end. */\n  readonly current: Signal<TourPosition | null> = this._current.asReadonly();\n  /** The last ``tour-error`` since the last start (fatal or not). */\n  readonly lastError: Signal<TourErrorDetail | null> = this._lastError.asReadonly();\n  /** Every overlay event, in order, delivered inside the Angular zone. */\n  readonly events: Observable<SteppyTourEvent> = this._events.asObservable();\n\n  private owner: object | null = null;\n  private host: TourHostElement | null = null;\n  private failed = false;\n  private waiters: ((host: TourHostElement | null) => void)[] = [];\n  private seq = 0;\n\n  /**\n   * Start a tour. Resolves ``true`` once it started, ``false`` when it could\n   * not (a ``tour-error`` says why), when no ``<steppy-tours>`` is mounted\n   * in time, when a later ``start()``/``stop()`` superseded this call, or on\n   * the server. Never rejects.\n   */\n  async start(tourId: string, options: TourStartOptions = {}): Promise<boolean> {\n    if (!this.browser) return false;\n    const seq = ++this.seq;\n    const host = await this.whenReady();\n    if (seq !== this.seq) return false;\n    if (!host) {\n      console.warn(\n        this.failed\n          ? `${PREFIX} start(\"${tourId}\"): the tour overlay failed to load`\n          : `${PREFIX} start(\"${tourId}\"): no <steppy-tours> is mounted, or the overlay did not load ` +\n              `within ${this.readyTimeout()} ms. Place <steppy-tours /> once in the app shell.`,\n      );\n      return false;\n    }\n    // Outside the zone: the overlay's observers, polls and frames must not\n    // drive change detection.\n    return this.zone.runOutsideAngular(() => host.start(tourId, options));\n  }\n\n  /** End the running tour (``reason`` is passed to ``tour-dismiss``); also cancels a waiting ``start()``. */\n  stop(reason?: string): void {\n    this.seq++;\n    this.flush(null);\n    const host = this.host;\n    if (host) this.zone.runOutsideAngular(() => host.stop(reason));\n  }\n\n  /** Advance the current step, whatever its kind. */\n  next(): void {\n    const host = this.host;\n    if (host) this.zone.runOutsideAngular(() => host.next());\n  }\n\n  // ── Used by <steppy-tours> ──────────────────────────────────────────────\n\n  /** @internal The first component to mount owns the overlay. */\n  ɵclaim(owner: object): boolean {\n    if (this.owner !== null && this.owner !== owner) return false;\n    this.owner = owner;\n    return true;\n  }\n\n  /** @internal The overlay is defined (``host``) or failed to load (``null``). */\n  ɵready(owner: object, host: TourHostElement | null): void {\n    if (this.owner !== owner) return;\n    this.host = host;\n    this.failed = host === null;\n    this.flush(host);\n  }\n\n  /** @internal The owning component was destroyed. */\n  ɵrelease(owner: object): void {\n    if (this.owner !== owner) return;\n    this.owner = null;\n    this.host = null;\n    this.failed = false;\n    this._active.set(false);\n    this._current.set(null);\n  }\n\n  /** @internal One overlay event (already inside the zone). */\n  ɵrecord(event: SteppyTourEvent): void {\n    switch (event.type) {\n      case 'tour-start':\n        this._active.set(true);\n        this._current.set(null);\n        this._lastError.set(null);\n        break;\n      case 'tour-step': {\n        const { tourId, stepId, index, total } = event.detail;\n        this._active.set(true);\n        this._current.set({ tourId, stepId, index, total });\n        break;\n      }\n      case 'tour-complete':\n      case 'tour-dismiss':\n        this._active.set(false);\n        this._current.set(null);\n        break;\n      case 'tour-error':\n        this._lastError.set(event.detail);\n        if (event.detail.fatal) {\n          this._active.set(false);\n          this._current.set(null);\n        }\n        break;\n      case 'tour-offpath':\n        break;\n    }\n    this._events.next(event);\n  }\n\n  // ── Internals ──────────────────────────────────────────────────────────────\n\n  private readyTimeout(): number {\n    return this.ɵconfig.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;\n  }\n\n  private whenReady(): Promise<TourHostElement | null> {\n    if (this.host) return Promise.resolve(this.host);\n    if (this.failed) return Promise.resolve(null);\n    return new Promise((resolve) => {\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const done = (host: TourHostElement | null) => {\n        clearTimeout(timer);\n        this.waiters = this.waiters.filter((w) => w !== done);\n        resolve(host);\n      };\n      this.waiters.push(done);\n      // Outside the zone: a pending timer would keep a zone.js app from ever\n      // becoming stable while it waits.\n      timer = this.zone.runOutsideAngular(() => setTimeout(() => done(null), this.readyTimeout()));\n    });\n  }\n\n  private flush(host: TourHostElement | null): void {\n    for (const waiter of [...this.waiters]) waiter(host);\n  }\n}\n\nfunction resolveLocale(source: SteppyLocaleSource | undefined): Signal<string> {\n  if (source === undefined) return computed(() => '');\n  if (typeof source === 'string') return computed(() => source);\n  if (isSignal(source)) return computed(() => source() ?? '');\n  const made = source();\n  return typeof made === 'string' ? computed(() => made) : computed(() => made() ?? '');\n}\n","import { inject, isDevMode, makeEnvironmentProviders, provideEnvironmentInitializer, type EnvironmentProviders } from '@angular/core';\n\nimport { STEPPY_TOURS_CONFIG, type SteppyToursConfig } from './config';\nimport { SteppyTours } from './tours.service';\n\n/**\n * Configure in-app tours for the app, in ``app.config.ts``:\n *\n * ```ts\n * provideSteppyTours({\n *   fallbackManifest: 'tours/tours.manifest.json',\n *   locale: () => {\n *     const translate = inject(TranslateService);\n *     return toSignal(translate.onLangChange.pipe(map((e) => e.lang)), { initialValue: translate.getCurrentLang() ?? '' });\n *   },\n * })\n * ```\n *\n * Then place ``<steppy-tours />`` once in the app shell.\n */\nexport function provideSteppyTours(config: SteppyToursConfig = {}): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    { provide: STEPPY_TOURS_CONFIG, useValue: config },\n    provideEnvironmentInitializer(() => {\n      if (isDevMode() && inject(SteppyTours).ɵconfig !== config) {\n        console.warn(\n          '[steppy-tours] provideSteppyTours() has no effect here: the tours service is a root ' +\n            'singleton. Call it in the application providers (app.config.ts), not in a lazy route.',\n        );\n      }\n    }),\n  ]);\n}\n","import { inject, NgZone } from '@angular/core';\nimport { Router, ROUTES } from '@angular/router';\nimport type { TourNavigate } from '@steppy/player/tour';\n\nimport type { SteppyToursConfig } from './config';\n\n/**\n * The ``navigate`` hook the overlay calls to reach a tour's entry route (or a\n * route linked from step text). Call it in an injection context.\n *\n * The overlay calls it from outside the Angular zone; the router — and the\n * routed view it renders — must run inside it, or a zone.js app never renders\n * the page the tour waits on. Returns ``null`` for ``'document'``, and when the\n * app has no routes, so the overlay falls back to a full page load.\n */\nexport function createNavigate(option: SteppyToursConfig['navigate'] = 'router'): TourNavigate | null {\n  if (option === 'document') return null;\n  const zone = inject(NgZone);\n  let go: TourNavigate;\n  if (option === 'router') {\n    if (!inject(ROUTES, { optional: true })) return null;\n    go = routerNavigate(inject(Router));\n  } else {\n    go = option;\n  }\n  // ``async``: a synchronous throw becomes a rejection, which the overlay reports.\n  return (path, ctx) => zone.run(async () => void (await go(path, ctx)));\n}\n\n/**\n * Navigate with the router and settle only once the router is where the tour\n * wants to be. ``navigateByUrl`` resolves ``false`` both for a refused\n * navigation and for one to the current URL, and ``true`` for one a guard\n * redirected elsewhere — so the outcome is read from ``router.url``. A\n * rejection makes the overlay fail the start at once (``entry-params``)\n * instead of waiting for a target that will never render.\n */\nexport function routerNavigate(router: Router): TourNavigate {\n  const pathOf = (url: string) => router.serializeUrl(router.parseUrl(url)).split(/[?#]/, 1)[0];\n  return async (_path, { appPath }) => {\n    const navigated = await router.navigateByUrl(appPath);\n    if (pathOf(router.url) === pathOf(appPath)) return;\n    throw new Error(\n      navigated\n        ? `the router redirected ${appPath} to ${router.url}`\n        : `the router did not navigate to ${appPath} (a guard or another navigation cancelled it)`,\n    );\n  };\n}\n","/**\n * The seam between the adapter and the tour overlay (``@steppy/player/tour``).\n *\n * Everything imported from the overlay at the top of this package is a *type*:\n * the overlay touches ``HTMLElement`` when its module loads, so its only\n * runtime reference is the dynamic ``import()`` in ``OVERLAY_LOADER``, which\n * runs in the browser, after the first render. Tests swap the loader for a fake\n * element on a tag of their own.\n *\n * One literal per line: ``tests/test_angular_adapter_sync.py`` reads the tag and\n * the event names with regular expressions and compares them with the overlay.\n */\n\nimport { InjectionToken } from '@angular/core';\nimport type { TourEventName, TourHostApi, TourSource, TourStringOverrides } from '@steppy/player/tour';\n\nexport const TOUR_HOST_TAG = 'steppy-tour-host';\nexport const TOUR_EVENT_NAMES = ['tour-start', 'tour-step', 'tour-complete', 'tour-dismiss', 'tour-offpath', 'tour-error'] as const;\n\n// Fails to compile when the overlay gains an event this list does not name.\ntype AssertNever<T extends never> = T;\nexport type ɵAllTourEventsListed = AssertNever<Exclude<TourEventName, (typeof TOUR_EVENT_NAMES)[number]>>;\n\n/** ``<steppy-tour-host>`` as the adapter drives it. */\nexport type TourHostElement = HTMLElement & TourHostApi;\n\nexport interface OverlayLoader {\n  /** The custom element tag the loader defines. */\n  readonly tag: string;\n  /** Load (and so define) the element. */\n  load(): Promise<unknown>;\n}\n\nexport const OVERLAY_LOADER = new InjectionToken<OverlayLoader>('steppy tour overlay', {\n  providedIn: 'root',\n  factory: () => ({ tag: TOUR_HOST_TAG, load: () => import('@steppy/player/tour') }),\n});\n\n/** What the adapter writes onto the element (``navigate`` is set once, at mount). */\nexport interface HostProps {\n  fallbackManifest: string;\n  manifest: string;\n  buildId: string;\n  guideOrigin: string;\n  locale: string;\n  disabled: boolean;\n  strings: TourStringOverrides | undefined;\n  source: TourSource | null;\n  targetTimeout?: number;\n  baseZIndex?: number;\n}\n\n/**\n * Write the props onto the element — before it is defined as well: the\n * overlay keeps properties set on the element before its upgrade.\n */\nexport function applyProps(el: TourHostElement, p: HostProps): void {\n  el.fallbackManifest = p.fallbackManifest;\n  el.manifest = p.manifest;\n  el.buildId = p.buildId;\n  el.guideOrigin = p.guideOrigin;\n  el.locale = p.locale;\n  el.disabled = p.disabled;\n  el.strings = p.strings;\n  el.source = p.source;\n  if (p.targetTimeout !== undefined) el.targetTimeout = p.targetTimeout;\n  if (p.baseZIndex !== undefined) el.baseZIndex = p.baseZIndex;\n}\n","import {\n  ChangeDetectionStrategy,\n  Component,\n  DOCUMENT,\n  DestroyRef,\n  ElementRef,\n  NgZone,\n  PLATFORM_ID,\n  afterNextRender,\n  computed,\n  effect,\n  inject,\n  input,\n  output,\n  signal,\n  untracked,\n  type OutputEmitterRef,\n} from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport type { TourEventDetailMap, TourSource, TourStringOverrides } from '@steppy/player/tour';\n\nimport { createNavigate } from './navigate';\nimport { OVERLAY_LOADER, TOUR_EVENT_NAMES, applyProps, type HostProps, type TourHostElement } from './overlay';\nimport { SteppyTours, type SteppyTourEvent } from './tours.service';\n\nconst PREFIX = '[steppy-tours]';\n\n/** ``undefined`` stays ``undefined`` (= use the config); anything else is read as a number. */\nfunction optionalNumber(value: unknown): number | undefined {\n  return value === undefined || value === null || value === '' ? undefined : Number(value);\n}\n\n/** ``undefined`` stays ``undefined``; a bare attribute (``''``) and ``'true'`` are true. */\nfunction optionalBoolean(value: unknown): boolean | undefined {\n  if (value === undefined || value === null) return undefined;\n  return value === '' || (value !== false && value !== 'false');\n}\n\n/**\n * The in-app tour overlay. Place it **once**, in the app shell:\n *\n * ```html\n * <router-outlet />\n * <steppy-tours />\n * ```\n *\n * It renders nothing on the server. In the browser it mounts\n * ``<steppy-tour-host>`` after the first render and loads the overlay\n * module lazily; every input overrides the matching\n * ``provideSteppyTours()`` setting. Start tours with the\n * ``SteppyTours`` service or the ``steppyTourStart`` directive.\n *\n * Destroying it suspends a running tour rather than dismissing it: the overlay\n * keeps its resume record, so a tour survives a shell swap. Call\n * ``SteppyTours.stop()`` first to end it for good.\n */\n@Component({\n  selector: 'steppy-tours',\n  template: '',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { style: 'display: contents' },\n})\nexport class SteppyToursComponent {\n  readonly fallbackManifest = input<string>();\n  readonly manifest = input<string>();\n  readonly buildId = input<string>();\n  readonly guideOrigin = input<string>();\n  /** ``null``/``undefined``: the configured locale source. ``''``: follow ``<html lang>``. */\n  readonly locale = input<string | null>();\n  readonly targetTimeout = input<number | undefined, unknown>(undefined, { transform: optionalNumber });\n  readonly baseZIndex = input<number | undefined, unknown>(undefined, { transform: optionalNumber });\n  readonly disabled = input<boolean | undefined, unknown>(undefined, { transform: optionalBoolean });\n  readonly strings = input<TourStringOverrides>();\n  readonly source = input<TourSource | null>();\n\n  readonly tourStart = output<TourEventDetailMap['tour-start']>();\n  readonly tourStep = output<TourEventDetailMap['tour-step']>();\n  readonly tourComplete = output<TourEventDetailMap['tour-complete']>();\n  readonly tourDismiss = output<TourEventDetailMap['tour-dismiss']>();\n  readonly tourOffpath = output<TourEventDetailMap['tour-offpath']>();\n  readonly tourError = output<TourEventDetailMap['tour-error']>();\n\n  private readonly tours = inject(SteppyTours);\n  private readonly config = this.tours.ɵconfig;\n  private readonly overlay = inject(OVERLAY_LOADER);\n  private readonly zone = inject(NgZone);\n  private readonly document = inject(DOCUMENT);\n  private readonly hostRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly browser = isPlatformBrowser(inject(PLATFORM_ID));\n  private readonly navigate = createNavigate(this.config.navigate);\n  private readonly el = signal<TourHostElement | null>(null);\n\n  private readonly outputs: { [K in keyof TourEventDetailMap]: OutputEmitterRef<TourEventDetailMap[K]> } = {\n    'tour-start': this.tourStart,\n    'tour-step': this.tourStep,\n    'tour-complete': this.tourComplete,\n    'tour-dismiss': this.tourDismiss,\n    'tour-offpath': this.tourOffpath,\n    'tour-error': this.tourError,\n  };\n\n  private readonly props = computed<HostProps>(() => {\n    const c = this.config;\n    const locale = this.locale();\n    const source = this.source();\n    return {\n      fallbackManifest: this.fallbackManifest() ?? c.fallbackManifest ?? '',\n      manifest: this.manifest() ?? c.manifest ?? '',\n      buildId: this.buildId() ?? c.buildId ?? '',\n      guideOrigin: this.guideOrigin() ?? c.guideOrigin ?? '',\n      locale: locale ?? this.tours.ɵlocale(),\n      disabled: this.disabled() ?? c.disabled ?? false,\n      strings: this.strings() ?? c.strings,\n      source: source !== undefined ? source : (c.source ?? null),\n      targetTimeout: this.targetTimeout() ?? c.targetTimeout,\n      baseZIndex: this.baseZIndex() ?? c.baseZIndex,\n    };\n  });\n\n  private readonly onEvent = (event: Event): void =>\n    this.zone.run(() => {\n      const record = { type: event.type, detail: (event as CustomEvent).detail } as SteppyTourEvent;\n      this.tours.ɵrecord(record);\n      (this.outputs[record.type] as OutputEmitterRef<unknown>).emit(record.detail);\n    });\n\n  constructor() {\n    // afterNextRender runs in the browser only, outside the Angular zone.\n    afterNextRender(() => this.mount());\n    effect(() => {\n      const el = this.el();\n      const props = this.props();\n      if (el) this.zone.runOutsideAngular(() => applyProps(el, props));\n    });\n    inject(DestroyRef).onDestroy(() => this.unmount());\n  }\n\n  private mount(): void {\n    if (!this.browser) return;\n    if (!this.tours.ɵclaim(this)) {\n      console.warn(`${PREFIX} another <steppy-tours> is already mounted; this one does nothing. Mount it once, in the app shell.`);\n      return;\n    }\n    const props = untracked(this.props);\n    if (!props.fallbackManifest && !props.manifest) {\n      console.warn(`${PREFIX} no manifest: set fallbackManifest (or manifest) in provideSteppyTours() or on <steppy-tours>`);\n    }\n    // The element is on the page — with its properties and listeners — before\n    // the overlay module defines it: the overlay keeps properties set before\n    // its upgrade, a resumed tour's tour-start is not missed, and anything that\n    // waits for the element to be defined finds it in the DOM.\n    const el = this.document.createElement(this.overlay.tag) as TourHostElement;\n    applyProps(el, props);\n    el.navigate = this.navigate;\n    for (const name of TOUR_EVENT_NAMES) el.addEventListener(name, this.onEvent);\n    this.hostRef.nativeElement.appendChild(el);\n    this.el.set(el);\n    this.overlay\n      .load()\n      .then(() => customElements.whenDefined(this.overlay.tag))\n      .then(\n        () => {\n          if (this.el() === el) this.tours.ɵready(this, el);\n        },\n        (err: unknown) => {\n          if (this.el() !== el) return;\n          console.error(`${PREFIX} the tour overlay failed to load`, err);\n          this.tours.ɵready(this, null);\n        },\n      );\n  }\n\n  private unmount(): void {\n    const el = untracked(this.el);\n    if (el) {\n      for (const name of TOUR_EVENT_NAMES) el.removeEventListener(name, this.onEvent);\n      el.remove();\n      this.el.set(null);\n    }\n    this.tours.ɵrelease(this);\n  }\n}\n","import { Directive, inject, input } from '@angular/core';\nimport type { TourStartOptions } from '@steppy/player/tour';\n\nimport { SteppyTours } from './tours.service';\n\n/**\n * Start a tour on click:\n *\n * ```html\n * <button steppyTourStart=\"create-invoice\">Show me how</button>\n * <button [steppyTourStart]=\"'send-invoice'\" [steppyTourParams]=\"{ invoiceId: id }\">Help</button>\n * ```\n */\n@Directive({\n  selector: '[steppyTourStart]',\n  host: { '(click)': 'onClick()' },\n})\nexport class SteppyTourStart {\n  readonly steppyTourStart = input.required<string>();\n  readonly steppyTourParams = input<Record<string, string | number>>();\n  readonly steppyTourStep = input<string>();\n\n  private readonly tours = inject(SteppyTours);\n\n  protected onClick(): void {\n    const options: TourStartOptions = {};\n    const params = this.steppyTourParams();\n    const step = this.steppyTourStep();\n    if (params) options.params = params;\n    if (step) options.step = step;\n    void this.tours.start(this.steppyTourStart(), options);\n  }\n}\n","/*\n * @steppy/angular — the Angular adapter for the Steppy in-app tour overlay.\n */\n\nexport { provideSteppyTours } from './provide';\nexport type { SteppyLocaleSource, SteppyNavigate, SteppyToursConfig } from './config';\nexport { SteppyTours, type SteppyTourEvent } from './tours.service';\nexport { SteppyToursComponent } from './tours.component';\nexport { SteppyTourStart } from './tour-start.directive';\nexport { routerNavigate } from './navigate';\n\n// Types only: erased at build time, so nothing from the overlay loads on the server.\nexport type {\n  TourErrorDetail,\n  TourEventDetailMap,\n  TourNavigateContext,\n  TourPosition,\n  TourSource,\n  TourStartOptions,\n  TourStringOverrides,\n} from '@steppy/player/tour';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["PREFIX"],"mappings":"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"}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@steppy/angular",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.0",
+  "description": "Angular adapter for the Steppy in-app tour overlay: provideSteppyTours(), <steppy-tours> and the SteppyTours service",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Steppy-dev/steppy.git",
+    "directory": "packages/angular"
+  },
+  "keywords": [
+    "angular",
+    "steppy",
+    "product-tour",
+    "onboarding",
+    "playwright"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=20.0.0 <23.0.0",
+    "@angular/core": ">=20.0.0 <23.0.0",
+    "@angular/router": ">=20.0.0 <23.0.0",
+    "@steppy/player": "0.3.0",
+    "rxjs": "^7.4.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/steppy-angular.mjs",
+  "typings": "types/steppy-angular.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/steppy-angular.d.ts",
+      "default": "./fesm2022/steppy-angular.mjs"
+    }
+  },
+  "type": "module"
 }

package/types/steppy-angular.d.ts

@@ -0,0 +1,248 @@
+import * as _angular_core from '@angular/core';
+import { Signal, EnvironmentProviders, OutputEmitterRef } from '@angular/core';
+import * as _steppy_player_tour from '@steppy/player/tour';
+import { TourNavigate, TourStringOverrides, TourSource, TourHostApi, TourEventDetailMap, TourPosition, TourErrorDetail, TourStartOptions } from '@steppy/player/tour';
+export { TourErrorDetail, TourEventDetailMap, TourNavigateContext, TourPosition, TourSource, TourStartOptions, TourStringOverrides } from '@steppy/player/tour';
+import { Observable } from 'rxjs';
+import * as _steppy_angular from '@steppy/angular';
+import { Router } from '@angular/router';
+
+/**
+ * Where the tours' language comes from. A string or a signal is used as is; a
+ * function is called once, in the root injection context, so it may
+ * ``inject()`` the app's i18n service and return a signal of its language.
+ * ``null``, ``undefined`` and ``''`` all mean "follow ``<html lang>``".
+ */
+type SteppyLocaleSource = string | Signal<string | null | undefined> | (() => string | Signal<string | null | undefined>);
+/** How a tour changes route; ``(path, {appPath, tourId}) => …`` for your own. */
+type SteppyNavigate = TourNavigate;
+interface SteppyToursConfig {
+    /** The tour manifest bundled with the app (same origin), e.g. ``tours/tours.manifest.json``. */
+    fallbackManifest?: string;
+    /** A remote manifest URL; may contain ``{buildId}``. */
+    manifest?: string;
+    /** The app's build id, for ``{buildId}``. Default: the bundled manifest's. */
+    buildId?: string;
+    /** The origin trusted for guide links. Default: the bundled manifest's. */
+    guideOrigin?: string;
+    /** Milliseconds to wait for a step's element (500–120000). Default: the overlay's 8000. */
+    targetTimeout?: number;
+    /** Stacking where the top layer is unavailable. Default: the overlay's. */
+    baseZIndex?: number;
+    /** Turns tours off; stops a running one. */
+    disabled?: boolean;
+    /** Chrome string overrides per locale (buttons, hints). */
+    strings?: TourStringOverrides;
+    /** Supply tour files yourself; see the overlay's ``source`` property. */
+    source?: TourSource | null;
+    /** The tours' language. Default: ``<html lang>``. */
+    locale?: SteppyLocaleSource;
+    /**
+     * ``'router'`` (default): the Angular router, inside the zone; a refused or
+     * redirected navigation fails the tour at once. ``'document'``: a full page
+     * load. Or a function of your own.
+     */
+    navigate?: 'router' | 'document' | SteppyNavigate;
+    /** How long ``start()`` waits for ``<steppy-tours>`` and the overlay to load. Default 10000 ms. */
+    readyTimeout?: number;
+}
+
+/**
+ * Configure in-app tours for the app, in ``app.config.ts``:
+ *
+ * ```ts
+ * provideSteppyTours({
+ *   fallbackManifest: 'tours/tours.manifest.json',
+ *   locale: () => {
+ *     const translate = inject(TranslateService);
+ *     return toSignal(translate.onLangChange.pipe(map((e) => e.lang)), { initialValue: translate.getCurrentLang() ?? '' });
+ *   },
+ * })
+ * ```
+ *
+ * Then place ``<steppy-tours />`` once in the app shell.
+ */
+declare function provideSteppyTours(config?: SteppyToursConfig): EnvironmentProviders;
+
+/**
+ * The seam between the adapter and the tour overlay (``@steppy/player/tour``).
+ *
+ * Everything imported from the overlay at the top of this package is a *type*:
+ * the overlay touches ``HTMLElement`` when its module loads, so its only
+ * runtime reference is the dynamic ``import()`` in ``OVERLAY_LOADER``, which
+ * runs in the browser, after the first render. Tests swap the loader for a fake
+ * element on a tag of their own.
+ *
+ * One literal per line: ``tests/test_angular_adapter_sync.py`` reads the tag and
+ * the event names with regular expressions and compares them with the overlay.
+ */
+
+/** ``<steppy-tour-host>`` as the adapter drives it. */
+type TourHostElement = HTMLElement & TourHostApi;
+
+/** One overlay event, as the service and the component outputs see it. */
+type SteppyTourEvent = {
+    [K in keyof TourEventDetailMap]: {
+        type: K;
+        detail: TourEventDetailMap[K];
+    };
+}[keyof TourEventDetailMap];
+/**
+ * Start and follow in-app tours from anywhere in the app.
+ *
+ * The overlay itself lives in ``<steppy-tours>``, placed once in the app
+ * shell; ``start()`` waits for it to be mounted and loaded (up to
+ * ``readyTimeout``), so a help button can call it during startup. State is
+ * built from the overlay's six events and exposed as signals; on the server
+ * every call is a no-op.
+ */
+declare class SteppyTours {
+    private readonly zone;
+    private readonly browser;
+    /** @internal */
+    readonly ɵconfig: SteppyToursConfig;
+    /** @internal The configured locale source, resolved once in the root injection context. */
+    readonly ɵlocale: Signal<string>;
+    private readonly _active;
+    private readonly _current;
+    private readonly _lastError;
+    private readonly _events;
+    /** A tour is running (from ``tour-start`` until it completes, is dismissed or fails). */
+    readonly active: Signal<boolean>;
+    /** The step shown, or ``null`` before the first step and after the end. */
+    readonly current: Signal<TourPosition | null>;
+    /** The last ``tour-error`` since the last start (fatal or not). */
+    readonly lastError: Signal<TourErrorDetail | null>;
+    /** Every overlay event, in order, delivered inside the Angular zone. */
+    readonly events: Observable<SteppyTourEvent>;
+    private owner;
+    private host;
+    private failed;
+    private waiters;
+    private seq;
+    /**
+     * Start a tour. Resolves ``true`` once it started, ``false`` when it could
+     * not (a ``tour-error`` says why), when no ``<steppy-tours>`` is mounted
+     * in time, when a later ``start()``/``stop()`` superseded this call, or on
+     * the server. Never rejects.
+     */
+    start(tourId: string, options?: TourStartOptions): Promise<boolean>;
+    /** End the running tour (``reason`` is passed to ``tour-dismiss``); also cancels a waiting ``start()``. */
+    stop(reason?: string): void;
+    /** Advance the current step, whatever its kind. */
+    next(): void;
+    /** @internal The first component to mount owns the overlay. */
+    ɵclaim(owner: object): boolean;
+    /** @internal The overlay is defined (``host``) or failed to load (``null``). */
+    ɵready(owner: object, host: TourHostElement | null): void;
+    /** @internal The owning component was destroyed. */
+    ɵrelease(owner: object): void;
+    /** @internal One overlay event (already inside the zone). */
+    ɵrecord(event: SteppyTourEvent): void;
+    private readyTimeout;
+    private whenReady;
+    private flush;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SteppyTours, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SteppyTours>;
+}
+
+/**
+ * The in-app tour overlay. Place it **once**, in the app shell:
+ *
+ * ```html
+ * <router-outlet />
+ * <steppy-tours />
+ * ```
+ *
+ * It renders nothing on the server. In the browser it mounts
+ * ``<steppy-tour-host>`` after the first render and loads the overlay
+ * module lazily; every input overrides the matching
+ * ``provideSteppyTours()`` setting. Start tours with the
+ * ``SteppyTours`` service or the ``steppyTourStart`` directive.
+ *
+ * Destroying it suspends a running tour rather than dismissing it: the overlay
+ * keeps its resume record, so a tour survives a shell swap. Call
+ * ``SteppyTours.stop()`` first to end it for good.
+ */
+declare class SteppyToursComponent {
+    readonly fallbackManifest: _angular_core.InputSignal<string | undefined>;
+    readonly manifest: _angular_core.InputSignal<string | undefined>;
+    readonly buildId: _angular_core.InputSignal<string | undefined>;
+    readonly guideOrigin: _angular_core.InputSignal<string | undefined>;
+    /** ``null``/``undefined``: the configured locale source. ``''``: follow ``<html lang>``. */
+    readonly locale: _angular_core.InputSignal<string | null | undefined>;
+    readonly targetTimeout: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly baseZIndex: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly strings: _angular_core.InputSignal<Partial<Record<string, Partial<_steppy_player_tour.TourStrings>>> | undefined>;
+    readonly source: _angular_core.InputSignal<TourSource | null | undefined>;
+    readonly tourStart: OutputEmitterRef<_steppy_player_tour.TourEventMeta & {
+        total: number;
+        source: _steppy_player_tour.TourSourceKind;
+        resumed: boolean;
+        entryNavigated: boolean;
+    }>;
+    readonly tourStep: OutputEmitterRef<_steppy_player_tour.TourStepPosition & {
+        advance: _steppy_player_tour.AdvanceKind;
+        reason: _steppy_player_tour.StepReason;
+    }>;
+    readonly tourComplete: OutputEmitterRef<_steppy_player_tour.TourEventMeta & {
+        total: number;
+    }>;
+    readonly tourDismiss: OutputEmitterRef<_steppy_player_tour.TourStepPosition & {
+        via: _steppy_player_tour.DismissVia;
+        reason?: string;
+    }>;
+    readonly tourOffpath: OutputEmitterRef<_steppy_player_tour.TourStepPosition & {
+        reason: "target-lost";
+    }>;
+    readonly tourError: OutputEmitterRef<_steppy_angular.TourErrorDetail>;
+    private readonly tours;
+    private readonly config;
+    private readonly overlay;
+    private readonly zone;
+    private readonly document;
+    private readonly hostRef;
+    private readonly browser;
+    private readonly navigate;
+    private readonly el;
+    private readonly outputs;
+    private readonly props;
+    private readonly onEvent;
+    constructor();
+    private mount;
+    private unmount;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SteppyToursComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SteppyToursComponent, "steppy-tours", never, { "fallbackManifest": { "alias": "fallbackManifest"; "required": false; "isSignal": true; }; "manifest": { "alias": "manifest"; "required": false; "isSignal": true; }; "buildId": { "alias": "buildId"; "required": false; "isSignal": true; }; "guideOrigin": { "alias": "guideOrigin"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "targetTimeout": { "alias": "targetTimeout"; "required": false; "isSignal": true; }; "baseZIndex": { "alias": "baseZIndex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "strings": { "alias": "strings"; "required": false; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; }, { "tourStart": "tourStart"; "tourStep": "tourStep"; "tourComplete": "tourComplete"; "tourDismiss": "tourDismiss"; "tourOffpath": "tourOffpath"; "tourError": "tourError"; }, never, never, true, never>;
+}
+
+/**
+ * Start a tour on click:
+ *
+ * ```html
+ * <button steppyTourStart="create-invoice">Show me how</button>
+ * <button [steppyTourStart]="'send-invoice'" [steppyTourParams]="{ invoiceId: id }">Help</button>
+ * ```
+ */
+declare class SteppyTourStart {
+    readonly steppyTourStart: _angular_core.InputSignal<string>;
+    readonly steppyTourParams: _angular_core.InputSignal<Record<string, string | number> | undefined>;
+    readonly steppyTourStep: _angular_core.InputSignal<string | undefined>;
+    private readonly tours;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SteppyTourStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SteppyTourStart, "[steppyTourStart]", never, { "steppyTourStart": { "alias": "steppyTourStart"; "required": true; "isSignal": true; }; "steppyTourParams": { "alias": "steppyTourParams"; "required": false; "isSignal": true; }; "steppyTourStep": { "alias": "steppyTourStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Navigate with the router and settle only once the router is where the tour
+ * wants to be. ``navigateByUrl`` resolves ``false`` both for a refused
+ * navigation and for one to the current URL, and ``true`` for one a guard
+ * redirected elsewhere — so the outcome is read from ``router.url``. A
+ * rejection makes the overlay fail the start at once (``entry-params``)
+ * instead of waiting for a target that will never render.
+ */
+declare function routerNavigate(router: Router): TourNavigate;
+
+export { SteppyTourStart, SteppyTours, SteppyToursComponent, provideSteppyTours, routerNavigate };
+export type { SteppyLocaleSource, SteppyNavigate, SteppyTourEvent, SteppyToursConfig };