@autometa/events 0.3.2 → 1.0.0-rc.0

package/README.md

@@ -1,3 +1,29 @@
-# Gherkin
+# @autometa/events (v1 draft)
 
-Gherkin implementation for @autometa.
+Autometa's event bus coordinates feature, rule, scenario, example, background, step, and hook lifecycles during a test run. The v1 rewrite introduces a richer taxonomy so runners can react to each Gherkin stage explicitly and attach structured context to their hooks.
+
+## Hook Vocabulary
+
+`HookKind` now exposes per-stage before/after hooks in addition to runner-level setup/teardown:
+
+- `beforeFeature` / `afterFeature`
+- `beforeRule` / `afterRule`
+- `beforeScenario` / `afterScenario`
+- `beforeScenarioOutline` / `afterScenarioOutline`
+- `beforeExample` / `afterExample`
+- `beforeBackground` / `afterBackground`
+- `beforeStep` / `afterStep`
+- `setup` / `teardown`
+- `custom`
+
+Each hook descriptor can include the feature, rule, scenario, outline, example, background, or step it targets so downstream tooling can scope side effects precisely.
+
+## Event Payloads
+
+Lifecycle events follow the same granularity (`feature.*`, `rule.*`, `scenario.*`, `scenarioOutline.*`, `example.*`, `background.*`, `step.*`). They carry the originating pickles, references, and metadata required to trace execution across async boundaries.
+
+The dispatcher guarantees in-order delivery. Emitters construct canonical payloads with generated IDs and timestamps so subscribers always receive comparable shapes regardless of the underlying runner.
+
+## Migration Notes
+
+Legacy `beforeEach`/`afterEach` and `beforeAll`/`afterAll` handlers must be remapped to the explicit stage hooks above. Packages awaiting migration (e.g. `@autometa/scopes`, `@autometa/test-builder`) should budget time to adopt the new event names when they move onto the v1 stack.

package/dist/bus.d.ts

@@ -0,0 +1,10 @@
+import { EventDispatcher } from "./dispatcher.js";
+import { EventEmitter } from "./emitter.js";
+export interface EventBus {
+    readonly dispatcher: EventDispatcher;
+    readonly emitter: EventEmitter;
+}
+export declare function getEventBus(): EventBus;
+export declare function getEventDispatcher(): EventDispatcher;
+export declare function getEventEmitter(): EventEmitter;
+export declare function resetEventBus(): void;

package/dist/dispatcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Event dispatcher for Autometa lifecycle events.
+ */
+import { type IContainer } from "@autometa/injection";
+import type { EventSubscriber, TestEvent } from "./types.js";
+export interface EventDispatcherOptions {
+    /**
+     * Optional container to use for resolving subscribers. If omitted a
+     * standalone container is created per dispatcher instance.
+     */
+    container?: IContainer;
+}
+export declare const EventDispatcherToken: import("@autometa/injection").Token<EventDispatcher>;
+export declare class EventDispatcher {
+    private readonly container;
+    private readonly subscribers;
+    private sequence;
+    constructor(container?: IContainer);
+    static create(options?: EventDispatcherOptions): EventDispatcher;
+    /**
+     * Subscribe to events of a particular type.
+     */
+    subscribe<T extends TestEvent>(type: T["type"], subscriber: EventSubscriber<T>): () => void;
+    /**
+     * Publish an event to all registered subscribers. Subscribers are awaited in
+     * series to preserve ordering guarantees; callers can fork when concurrency is
+     * desired.
+     */
+    dispatch<T extends TestEvent>(event: T): Promise<void>;
+    clear(): void;
+}

package/dist/emitter.d.ts

@@ -0,0 +1,97 @@
+import type { SimpleExampleGroup, SimplePickle, SimplePickleFeatureRef, SimplePickleRuleRef, SimplePickleScenarioRef, SimplePickleStep, SimpleScenario, SimpleScenarioOutline } from "@autometa/gherkin";
+import { EventDispatcher } from "./dispatcher.js";
+import type { HookDescriptor } from "./hooks.js";
+import type { ErrorEvent } from "./types.js";
+import type { TestStatus } from "./status.js";
+export interface EventEmitterOptions {
+    createId?: () => string;
+    now?: () => number;
+}
+interface BaseEmitOptions {
+    id?: string;
+    timestamp?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FeatureLifecycleOptions extends BaseEmitOptions {
+    feature: SimplePickleFeatureRef;
+}
+export interface RuleLifecycleOptions extends FeatureLifecycleOptions {
+    rule: SimplePickleRuleRef;
+}
+export interface ScenarioLifecycleOptions extends BaseEmitOptions {
+    feature: SimplePickleFeatureRef;
+    scenario: SimplePickleScenarioRef;
+    pickle: SimplePickle;
+    rule?: SimplePickleRuleRef;
+}
+export interface ScenarioOutlineLifecycleOptions extends BaseEmitOptions {
+    feature: SimplePickleFeatureRef;
+    scenarioOutline: SimpleScenarioOutline;
+    rule?: SimplePickleRuleRef;
+}
+export interface ExampleLifecycleOptions extends BaseEmitOptions {
+    feature: SimplePickleFeatureRef;
+    scenarioOutline: SimpleScenarioOutline;
+    example: SimpleExampleGroup;
+    pickle: SimplePickle;
+    rule?: SimplePickleRuleRef;
+}
+export interface BackgroundLifecycleOptions extends BaseEmitOptions {
+    feature: SimplePickleFeatureRef;
+    background: SimpleScenario;
+    pickle: SimplePickle;
+    rule?: SimplePickleRuleRef;
+}
+export interface StepLifecycleOptions extends ScenarioLifecycleOptions {
+    step: SimplePickleStep;
+}
+export interface HookEmitOptions extends BaseEmitOptions {
+    hook: HookDescriptor;
+}
+export interface StatusEmitOptions extends BaseEmitOptions {
+    status: TestStatus;
+    previousStatus?: TestStatus;
+    feature?: SimplePickleFeatureRef;
+    rule?: SimplePickleRuleRef;
+    scenario?: SimplePickleScenarioRef;
+    scenarioOutline?: SimpleScenarioOutline;
+    example?: SimpleExampleGroup;
+    pickle?: SimplePickle;
+}
+export interface ErrorEmitOptions extends BaseEmitOptions {
+    error: unknown;
+    phase: ErrorEvent["phase"];
+    feature?: SimplePickleFeatureRef;
+    rule?: SimplePickleRuleRef;
+    scenario?: SimplePickleScenarioRef;
+    scenarioOutline?: SimpleScenarioOutline;
+    example?: SimpleExampleGroup;
+    background?: SimpleScenario;
+    pickle?: SimplePickle;
+}
+export declare class EventEmitter {
+    private readonly dispatcher;
+    private readonly createId;
+    private readonly now;
+    constructor(dispatcher: EventDispatcher, options?: EventEmitterOptions);
+    featureStarted(options: FeatureLifecycleOptions): Promise<void>;
+    featureCompleted(options: FeatureLifecycleOptions): Promise<void>;
+    ruleStarted(options: RuleLifecycleOptions): Promise<void>;
+    ruleCompleted(options: RuleLifecycleOptions): Promise<void>;
+    scenarioStarted(options: ScenarioLifecycleOptions): Promise<void>;
+    scenarioCompleted(options: ScenarioLifecycleOptions): Promise<void>;
+    scenarioOutlineStarted(options: ScenarioOutlineLifecycleOptions): Promise<void>;
+    scenarioOutlineCompleted(options: ScenarioOutlineLifecycleOptions): Promise<void>;
+    exampleStarted(options: ExampleLifecycleOptions): Promise<void>;
+    exampleCompleted(options: ExampleLifecycleOptions): Promise<void>;
+    backgroundStarted(options: BackgroundLifecycleOptions): Promise<void>;
+    backgroundCompleted(options: BackgroundLifecycleOptions): Promise<void>;
+    stepStarted(options: StepLifecycleOptions): Promise<void>;
+    stepCompleted(options: StepLifecycleOptions): Promise<void>;
+    hookStarted(options: HookEmitOptions): Promise<void>;
+    hookCompleted(options: HookEmitOptions): Promise<void>;
+    statusChanged(options: StatusEmitOptions): Promise<void>;
+    errorRaised(options: ErrorEmitOptions): Promise<void>;
+    private base;
+}
+export {};

package/dist/hooks.d.ts

@@ -0,0 +1,41 @@
+import { SimplePickle, SimplePickleFeatureRef, SimplePickleRuleRef, SimplePickleScenarioRef, SimplePickleStep, SimpleScenarioOutline, SimpleExampleGroup, SimpleScenario } from "@autometa/gherkin";
+/** Canonical hook kinds recognised by the Autometa runner. */
+export declare const HookKind: {
+    readonly BEFORE_FEATURE: "beforeFeature";
+    readonly AFTER_FEATURE: "afterFeature";
+    readonly BEFORE_RULE: "beforeRule";
+    readonly AFTER_RULE: "afterRule";
+    readonly BEFORE_SCENARIO: "beforeScenario";
+    readonly AFTER_SCENARIO: "afterScenario";
+    readonly BEFORE_SCENARIO_OUTLINE: "beforeScenarioOutline";
+    readonly AFTER_SCENARIO_OUTLINE: "afterScenarioOutline";
+    readonly BEFORE_EXAMPLE: "beforeExample";
+    readonly AFTER_EXAMPLE: "afterExample";
+    readonly BEFORE_BACKGROUND: "beforeBackground";
+    readonly AFTER_BACKGROUND: "afterBackground";
+    readonly BEFORE_STEP: "beforeStep";
+    readonly AFTER_STEP: "afterStep";
+    readonly SETUP: "setup";
+    readonly TEARDOWN: "teardown";
+    readonly CUSTOM: "custom";
+};
+export type HookKind = (typeof HookKind)[keyof typeof HookKind];
+export interface HookDescriptor {
+    /** Categorises when the hook is executed. */
+    kind: HookKind;
+    /** Optional human friendly name for diagnostics. */
+    name?: string;
+    /** Path or identifier that produced the hook for richer reporting. */
+    source?: string;
+    /** Stage-specific context for the hook, when available. */
+    feature?: SimplePickleFeatureRef;
+    rule?: SimplePickleRuleRef;
+    scenario?: SimplePickleScenarioRef;
+    scenarioOutline?: SimpleScenarioOutline;
+    example?: SimpleExampleGroup;
+    background?: SimpleScenario;
+    step?: SimplePickleStep;
+    pickle?: SimplePickle;
+    /** Arbitrary metadata emitted by the hook author. */
+    metadata?: Record<string, unknown>;
+}

package/dist/index.cjs

@@ -0,0 +1,424 @@
+'use strict';
+
+var injection = require('@autometa/injection');
+
+// src/dispatcher.ts
+var EventDispatcherToken = injection.createToken(
+  "@autometa/events/dispatcher"
+);
+var EventDispatcher = class _EventDispatcher {
+  constructor(container = injection.createContainer()) {
+    this.container = container;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.sequence = 0;
+  }
+  static create(options = {}) {
+    const container = options.container ?? injection.createContainer();
+    if (!container.isRegistered(EventDispatcherToken)) {
+      container.registerValue(
+        EventDispatcherToken,
+        new _EventDispatcher(container),
+        { scope: injection.Scope.SINGLETON }
+      );
+    }
+    return container.resolve(EventDispatcherToken);
+  }
+  /**
+   * Subscribe to events of a particular type.
+   */
+  subscribe(type, subscriber) {
+    const set = this.subscribers.get(type) ?? /* @__PURE__ */ new Set();
+    set.add(subscriber);
+    this.subscribers.set(type, set);
+    return () => {
+      set.delete(subscriber);
+      if (set.size === 0) {
+        this.subscribers.delete(type);
+      }
+    };
+  }
+  /**
+   * Publish an event to all registered subscribers. Subscribers are awaited in
+   * series to preserve ordering guarantees; callers can fork when concurrency is
+   * desired.
+   */
+  async dispatch(event) {
+    const envelope = {
+      sequence: ++this.sequence,
+      event
+    };
+    const listeners = this.subscribers.get(event.type);
+    if (!listeners || listeners.size === 0) {
+      return;
+    }
+    for (const listener of listeners) {
+      await listener(envelope);
+    }
+  }
+  clear() {
+    this.subscribers.clear();
+    this.sequence = 0;
+  }
+};
+
+// src/emitter.ts
+var defaultIdFactory = () => {
+  const crypto = globalThis.crypto;
+  if (crypto && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+var EventEmitter = class {
+  constructor(dispatcher, options = {}) {
+    this.dispatcher = dispatcher;
+    this.createId = options.createId ?? defaultIdFactory;
+    this.now = options.now ?? Date.now;
+  }
+  async featureStarted(options) {
+    const event = {
+      type: "feature.started",
+      feature: options.feature,
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async featureCompleted(options) {
+    const event = {
+      type: "feature.completed",
+      feature: options.feature,
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async ruleStarted(options) {
+    const event = {
+      type: "rule.started",
+      feature: options.feature,
+      rule: options.rule,
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async ruleCompleted(options) {
+    const event = {
+      type: "rule.completed",
+      feature: options.feature,
+      rule: options.rule,
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioStarted(options) {
+    const event = {
+      type: "scenario.started",
+      feature: options.feature,
+      scenario: options.scenario,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioCompleted(options) {
+    const event = {
+      type: "scenario.completed",
+      feature: options.feature,
+      scenario: options.scenario,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioOutlineStarted(options) {
+    const event = {
+      type: "scenarioOutline.started",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioOutlineCompleted(options) {
+    const event = {
+      type: "scenarioOutline.completed",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async exampleStarted(options) {
+    const event = {
+      type: "example.started",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      example: options.example,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async exampleCompleted(options) {
+    const event = {
+      type: "example.completed",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      example: options.example,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async backgroundStarted(options) {
+    const event = {
+      type: "background.started",
+      feature: options.feature,
+      background: options.background,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async backgroundCompleted(options) {
+    const event = {
+      type: "background.completed",
+      feature: options.feature,
+      background: options.background,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async stepStarted(options) {
+    const event = {
+      type: "step.started",
+      feature: options.feature,
+      scenario: options.scenario,
+      step: options.step,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async stepCompleted(options) {
+    const event = {
+      type: "step.completed",
+      feature: options.feature,
+      scenario: options.scenario,
+      step: options.step,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async hookStarted(options) {
+    const event = {
+      type: "hook.started",
+      hook: options.hook,
+      ...options.hook.feature ? { feature: options.hook.feature } : {},
+      ...options.hook.rule ? { rule: options.hook.rule } : {},
+      ...options.hook.scenario ? { scenario: options.hook.scenario } : {},
+      ...options.hook.scenarioOutline ? { scenarioOutline: options.hook.scenarioOutline } : {},
+      ...options.hook.example ? { example: options.hook.example } : {},
+      ...options.hook.background ? { background: options.hook.background } : {},
+      ...options.hook.step ? { step: options.hook.step } : {},
+      ...options.hook.pickle ? { pickle: options.hook.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async hookCompleted(options) {
+    const event = {
+      type: "hook.completed",
+      hook: options.hook,
+      ...options.hook.feature ? { feature: options.hook.feature } : {},
+      ...options.hook.rule ? { rule: options.hook.rule } : {},
+      ...options.hook.scenario ? { scenario: options.hook.scenario } : {},
+      ...options.hook.scenarioOutline ? { scenarioOutline: options.hook.scenarioOutline } : {},
+      ...options.hook.example ? { example: options.hook.example } : {},
+      ...options.hook.background ? { background: options.hook.background } : {},
+      ...options.hook.step ? { step: options.hook.step } : {},
+      ...options.hook.pickle ? { pickle: options.hook.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async statusChanged(options) {
+    const event = {
+      type: "status.changed",
+      status: options.status,
+      ...options.previousStatus ? { previousStatus: options.previousStatus } : {},
+      ...options.feature ? { feature: options.feature } : {},
+      ...options.rule ? { rule: options.rule } : {},
+      ...options.scenario ? { scenario: options.scenario } : {},
+      ...options.scenarioOutline ? { scenarioOutline: options.scenarioOutline } : {},
+      ...options.example ? { example: options.example } : {},
+      ...options.pickle ? { pickle: options.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async errorRaised(options) {
+    const event = {
+      type: "error",
+      error: options.error,
+      phase: options.phase,
+      ...options.feature ? { feature: options.feature } : {},
+      ...options.rule ? { rule: options.rule } : {},
+      ...options.scenario ? { scenario: options.scenario } : {},
+      ...options.scenarioOutline ? { scenarioOutline: options.scenarioOutline } : {},
+      ...options.example ? { example: options.example } : {},
+      ...options.background ? { background: options.background } : {},
+      ...options.pickle ? { pickle: options.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  base(options) {
+    const base = {
+      id: options.id ?? this.createId(),
+      timestamp: options.timestamp ?? this.now()
+    };
+    if (options.metadata !== void 0) {
+      base.metadata = options.metadata;
+    }
+    return base;
+  }
+};
+
+// src/bus.ts
+var BUS_KEY = Symbol.for("@autometa/events/bus");
+function getEventBus() {
+  const store = globalThis;
+  const existing = store[BUS_KEY];
+  if (existing) {
+    return existing;
+  }
+  const dispatcher = EventDispatcher.create();
+  const emitter = new EventEmitter(dispatcher);
+  const bus = { dispatcher, emitter };
+  store[BUS_KEY] = bus;
+  return bus;
+}
+function getEventDispatcher() {
+  return getEventBus().dispatcher;
+}
+function getEventEmitter() {
+  return getEventBus().emitter;
+}
+function resetEventBus() {
+  const store = globalThis;
+  const existing = store[BUS_KEY];
+  if (existing) {
+    existing.dispatcher.clear();
+  }
+  store[BUS_KEY] = void 0;
+}
+
+// src/hooks.ts
+var HookKind = {
+  BEFORE_FEATURE: "beforeFeature",
+  AFTER_FEATURE: "afterFeature",
+  BEFORE_RULE: "beforeRule",
+  AFTER_RULE: "afterRule",
+  BEFORE_SCENARIO: "beforeScenario",
+  AFTER_SCENARIO: "afterScenario",
+  BEFORE_SCENARIO_OUTLINE: "beforeScenarioOutline",
+  AFTER_SCENARIO_OUTLINE: "afterScenarioOutline",
+  BEFORE_EXAMPLE: "beforeExample",
+  AFTER_EXAMPLE: "afterExample",
+  BEFORE_BACKGROUND: "beforeBackground",
+  AFTER_BACKGROUND: "afterBackground",
+  BEFORE_STEP: "beforeStep",
+  AFTER_STEP: "afterStep",
+  SETUP: "setup",
+  TEARDOWN: "teardown",
+  CUSTOM: "custom"
+};
+
+// src/listener.ts
+function registerTestListener(listener, options = {}) {
+  const dispatcher = options.dispatcher ?? getEventDispatcher();
+  const unsubscribers = [];
+  const subscribe = (type, handler) => {
+    if (!handler && !listener.onEvent) {
+      return;
+    }
+    unsubscribers.push(
+      dispatcher.subscribe(type, async (envelope) => {
+        if (listener.onEvent) {
+          await listener.onEvent(envelope);
+        }
+        if (handler) {
+          await handler(envelope);
+        }
+      })
+    );
+  };
+  subscribe("feature.started", listener.onFeatureStarted);
+  subscribe("feature.completed", listener.onFeatureCompleted);
+  subscribe("rule.started", listener.onRuleStarted);
+  subscribe("rule.completed", listener.onRuleCompleted);
+  subscribe("scenario.started", listener.onScenarioStarted);
+  subscribe("scenario.completed", listener.onScenarioCompleted);
+  subscribe(
+    "scenarioOutline.started",
+    listener.onScenarioOutlineStarted
+  );
+  subscribe(
+    "scenarioOutline.completed",
+    listener.onScenarioOutlineCompleted
+  );
+  subscribe("example.started", listener.onExampleStarted);
+  subscribe("example.completed", listener.onExampleCompleted);
+  subscribe("background.started", listener.onBackgroundStarted);
+  subscribe("background.completed", listener.onBackgroundCompleted);
+  subscribe("step.started", listener.onStepStarted);
+  subscribe("step.completed", listener.onStepCompleted);
+  subscribe("hook.started", listener.onHookStarted);
+  subscribe("hook.completed", listener.onHookCompleted);
+  subscribe("status.changed", listener.onStatusChanged);
+  subscribe("error", listener.onError);
+  return () => {
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe();
+    }
+  };
+}
+
+// src/status.ts
+var TestStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  PASSED: "passed",
+  FAILED: "failed",
+  SKIPPED: "skipped",
+  BROKEN: "broken"
+};
+function isTerminalStatus(status) {
+  return status === TestStatus.PASSED || status === TestStatus.FAILED || status === TestStatus.SKIPPED || status === TestStatus.BROKEN;
+}
+
+exports.EventDispatcher = EventDispatcher;
+exports.EventDispatcherToken = EventDispatcherToken;
+exports.EventEmitter = EventEmitter;
+exports.HookKind = HookKind;
+exports.TestStatus = TestStatus;
+exports.getEventBus = getEventBus;
+exports.getEventDispatcher = getEventDispatcher;
+exports.getEventEmitter = getEventEmitter;
+exports.isTerminalStatus = isTerminalStatus;
+exports.registerTestListener = registerTestListener;
+exports.resetEventBus = resetEventBus;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map