@dcl/sdk 7.29.1-35901015152.commit-d1b7b96 → 7.29.1-35917671376.commit-046b268

package/explorer-ui/index.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="@dcl/js-runtime" />
+import { ExplorerUi, GrowOnlyValueSetComponentDefinition, PBExplorerItemPurchaseResult, PBExplorerUiEventsResult } from '@dcl/ecs';
+import { OpenExplorerUiResult } from '~system/RestrictedActions';
+export { ExplorerUi, OpenExplorerUiResult };
+/** @public */
+export type CorrelatedEvent = {
+    timestamp: number;
+    requestId: number;
+};
+/**
+ * A named stream of events that this helper can collect and stop on.
+ * @public
+ */
+export type Channel<N extends string = string, T extends CorrelatedEvent = CorrelatedEvent> = {
+    readonly name: N;
+    readonly component: GrowOnlyValueSetComponentDefinition<T>;
+};
+/** @public */
+export type AnyChannel = Channel<string, any>;
+/**
+ * Wraps a grow-only result component as a {@link Channel}. The name must be unique within a scene.
+ * @public
+ */
+export declare function channel<N extends string, T extends CorrelatedEvent>(name: N, component: GrowOnlyValueSetComponentDefinition<T>): Channel<N, T>;
+/** Panel lifecycle events: opened and closed. @public */
+export declare const ExplorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult>;
+/** Outcome of an `EU_ITEM_PURCHASE` flow: purchased, dismissed or failed. @public */
+export declare const ItemPurchase: Channel<'itemPurchase', PBExplorerItemPurchaseResult>;
+/**
+ * The `$case` names of a channel's event union.
+ * @public
+ */
+export type CaseOf<C extends AnyChannel> = C extends Channel<any, infer T> ? Extract<T[keyof T], {
+    $case: string;
+}>['$case'] : never;
+/** @public */
+export type Variant<C extends AnyChannel = AnyChannel, K extends string = string> = {
+    readonly channel: C;
+    readonly $case: K;
+};
+/** @public */
+export declare function variant<C extends AnyChannel, K extends CaseOf<C>>(ch: C, $case: K): Variant<C, K>;
+/**
+ * What ends the wait before the panel closes: any event on a channel, or one `$case` of it.
+ * @public
+ */
+export type StopCondition = AnyChannel | Variant;
+/** @public */
+export type Collected<C> = C extends Channel<infer N, infer T> ? {
+    channel: N;
+    event: T;
+} : never;
+/**
+ * How the wait ended.
+ * - `closed`: the panel this call opened was closed.
+ * - `matched`: `until` fired first, so the panel may still be on screen.
+ * - `notOpened`: this call did not open anything. `openResult` says why.
+ * - `timedOut`: `timeoutMs` elapsed first.
+ *
+ * `events` always holds everything collected, the event that stopped the wait included.
+ * @public
+ */
+export type WaitOutcome<C extends readonly AnyChannel[]> = {
+    $case: 'closed';
+    events: readonly Collected<C[number]>[];
+} | {
+    $case: 'matched';
+    events: readonly Collected<C[number]>[];
+} | {
+    $case: 'notOpened';
+    openResult: OpenExplorerUiResult;
+} | {
+    $case: 'timedOut';
+    events: readonly Collected<C[number]>[];
+};
+/** @public */
+export type WaitOptions<C extends readonly AnyChannel[]> = {
+    /** Channels whose events land in `events`. Defaults to none. */
+    collect?: C;
+    /** Stops the wait early. The panel closing always stops it regardless. */
+    until?: StopCondition;
+    /**
+     * Bounds the wait, in milliseconds. On expiry the promise resolves with `$case: 'timedOut'`.
+     * No default, because a panel can stay open for minutes. Without it, an explorer that opens
+     * a panel and then emits no `closed` leaves the promise pending for the scene's whole life.
+     */
+    timeoutMs?: number;
+};
+/** @public */
+export type OpenExplorerUiRequest = {
+    ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>;
+    itemPurchase?: undefined;
+} | {
+    ui: ExplorerUi.EU_ITEM_PURCHASE;
+    itemPurchase: {
+        urn: string;
+    };
+};
+/**
+ * Signature of {@link openExplorerUiAndWait}. The second overload takes a bare `ui`, so a
+ * computed panel value needs no narrowing.
+ * @public
+ */
+export interface OpenExplorerUiAndWait {
+    <const C extends readonly AnyChannel[] = []>(request: OpenExplorerUiRequest, options?: WaitOptions<C>): Promise<WaitOutcome<C>>;
+    (ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>): Promise<WaitOutcome<[]>>;
+}
+/**
+ * Opens an explorer panel and waits for the session it started. The wait ends when the panel
+ * closes. See {@link WaitOptions} to collect events, to stop earlier or to bound the wait.
+ *
+ * Every lifecycle outcome resolves, see {@link WaitOutcome}. The promise rejects only when an
+ * event cannot be attributed to a call at all: an explorer too old to echo `request_id`
+ * paired with a panel that can coexist with another one.
+ *
+ * @public
+ */
+export declare const openExplorerUiAndWait: OpenExplorerUiAndWait;

package/explorer-ui/index.js

@@ -0,0 +1,235 @@
+import { engine, ExplorerItemPurchaseResult, ExplorerUi, ExplorerUiEventsResult } from '@dcl/ecs';
+import { openExplorerUi, OpenExplorerUiResult } from '~system/RestrictedActions';
+export { ExplorerUi, OpenExplorerUiResult };
+// What an explorer that does not echo request_id, or a user-initiated action, leaves on the wire.
+const UNCORRELATED = 0;
+// Panels that can be on screen next to another panel. The `ui` field alone cannot attribute
+// their events, so an event on one of these panels must carry a request_id.
+const CONCURRENT_PANELS = [7 /* ExplorerUi.EU_ITEM_PURCHASE */];
+/**
+ * Wraps a grow-only result component as a {@link Channel}. The name must be unique within a scene.
+ * @public
+ */
+export function channel(name, component) {
+    return { name, component };
+}
+/** Panel lifecycle events: opened and closed. @public */
+export const ExplorerUiEvents = /* @__PURE__ */ channel('explorerUi', ExplorerUiEventsResult);
+/** Outcome of an `EU_ITEM_PURCHASE` flow: purchased, dismissed or failed. @public */
+export const ItemPurchase = /* @__PURE__ */ channel('itemPurchase', ExplorerItemPurchaseResult);
+/** @public */
+export function variant(ch, $case) {
+    return { channel: ch, $case };
+}
+/** @internal exposed for tests */
+export const EXPLORER_UI_WAIT_TIMEOUT_SYSTEM = 'explorer-ui-wait-timeout';
+// Lowest priority sorts this system last, so when it removes itself mid-tick it splices the
+// last element of the array the engine is iterating and skips no other system.
+const TIMEOUT_SYSTEM_PRIORITY = Number.MIN_SAFE_INTEGER;
+// ts-proto renders a `oneof` as one wrapper property `{ $case, [$case]: value }`. Finding that
+// property by shape keeps the helper independent of the name each message gave it: `event` on
+// one message, `status` on another.
+function caseOf(event) {
+    for (const key of Object.keys(event)) {
+        const value = event[key];
+        if (value && typeof value === 'object' && typeof value.$case === 'string') {
+            return value.$case;
+        }
+    }
+    return undefined;
+}
+function normalizeStop(stop) {
+    return '$case' in stop ? { channel: stop.channel, $case: stop.$case } : { channel: stop, $case: undefined };
+}
+/** @internal test seam. The production instance is {@link openExplorerUiAndWait}. */
+export function create(deps) {
+    const { engine: engineInstance, openExplorerUi: openExplorerUiFn, explorerUiEvents } = deps;
+    const root = engineInstance.RootEntity;
+    const sessions = new Map();
+    // Keyed by name, so two wrappers around the same component arm one listener, not two.
+    const armed = new Map();
+    // Starts at 1 so a minted id never collides with UNCORRELATED.
+    let nextRequestId = 1;
+    let timeoutSystemAdded = false;
+    function arm(ch) {
+        const bound = armed.get(ch.name);
+        if (bound) {
+            if (bound !== ch.component) {
+                throw new Error(`openExplorerUiAndWait: channel name '${ch.name}' is already bound to a different component. ` +
+                    `Channel names identify a stream, so they have to be unique within a scene.`);
+            }
+            return;
+        }
+        armed.set(ch.name, ch.component);
+        const name = ch.name;
+        // onChange has no unsubscribe, so one listener per channel lives for the engine's lifetime.
+        ch.component.onChange(root, (value) => {
+            // `undefined` arrives on DELETE_ENTITY. Otherwise `value` is one appended element,
+            // not the whole set.
+            if (value)
+                deliver(name, value);
+        });
+    }
+    function attribute(session, name, event) {
+        if (event.requestId === session.requestId)
+            return 'yes';
+        if (event.requestId !== UNCORRELATED)
+            return 'no';
+        // Only the lifecycle channel carries a second discriminator, `ui`, and it identifies a
+        // session only while panels cannot coexist. A second call for the same panel is answered
+        // WAS_ALREADY_OPEN, so at most one session per non-concurrent panel is ever live.
+        if (session.correlationRequired || name !== explorerUiEvents.name)
+            return 'ambiguous';
+        return event.ui === session.ui ? 'yes' : 'no';
+    }
+    function deliver(name, event) {
+        // Settling deletes from `sessions` mid-iteration, which a Map tolerates. Nothing adds.
+        for (const session of sessions.values()) {
+            if (!session.watched.has(name))
+                continue;
+            const attribution = attribute(session, name, event);
+            if (attribution === 'no')
+                continue;
+            if (attribution === 'ambiguous') {
+                failSession(session, new Error(`openExplorerUiAndWait: got a '${name}' event with no request_id, and nothing else identifies ` +
+                    `the call it belongs to. This explorer does not echo OpenExplorerUiRequest.request_id.`));
+                continue;
+            }
+            accept(session, name, event);
+        }
+    }
+    function accept(session, name, event) {
+        if (session.collect.has(name))
+            session.events.push({ channel: name, event });
+        // The close is terminal and wins over `until`, because `matched` would tell the caller
+        // that the panel is still on screen.
+        if (name === explorerUiEvents.name && caseOf(event) === 'closed') {
+            settleSession(session, { $case: 'closed', events: session.events });
+            return;
+        }
+        const until = session.until;
+        if (!until || until.channel !== name)
+            return;
+        if (until.$case === undefined || until.$case === caseOf(event)) {
+            settleSession(session, { $case: 'matched', events: session.events });
+        }
+    }
+    function settleSession(session, outcome) {
+        if (session.settled)
+            return;
+        session.settled = true;
+        sessions.delete(session.requestId);
+        session.settle(outcome);
+        maybeRemoveTimeoutSystem();
+    }
+    function failSession(session, error) {
+        if (session.settled)
+            return;
+        session.settled = true;
+        sessions.delete(session.requestId);
+        session.fail(error);
+        maybeRemoveTimeoutSystem();
+    }
+    function hasTimedSession() {
+        for (const session of sessions.values()) {
+            if (session.timeoutMs !== undefined)
+                return true;
+        }
+        return false;
+    }
+    function maybeRemoveTimeoutSystem() {
+        if (!timeoutSystemAdded || hasTimedSession())
+            return;
+        timeoutSystemAdded = false;
+        engineInstance.removeSystem(EXPLORER_UI_WAIT_TIMEOUT_SYSTEM);
+    }
+    function ensureTimeoutSystem() {
+        if (timeoutSystemAdded)
+            return;
+        timeoutSystemAdded = true;
+        // The scene runtime has no timers, so elapsed time is accumulated from the engine's dt.
+        engineInstance.addSystem((dt) => {
+            for (const session of sessions.values()) {
+                if (session.timeoutMs === undefined)
+                    continue;
+                session.elapsedMs += dt * 1000;
+                if (session.elapsedMs >= session.timeoutMs) {
+                    settleSession(session, { $case: 'timedOut', events: session.events });
+                }
+            }
+            maybeRemoveTimeoutSystem();
+        }, TIMEOUT_SYSTEM_PRIORITY, EXPLORER_UI_WAIT_TIMEOUT_SYSTEM);
+    }
+    async function openExplorerUiAndWait(request, options) {
+        const { ui, itemPurchase } = typeof request === 'number' ? { ui: request, itemPurchase: undefined } : request;
+        const requestId = nextRequestId++;
+        const collect = options?.collect ?? [];
+        const collectNames = new Set();
+        for (const ch of collect)
+            collectNames.add(ch.name);
+        const stop = options?.until ? normalizeStop(options.until) : undefined;
+        const watched = new Set(collectNames);
+        watched.add(explorerUiEvents.name);
+        if (stop)
+            watched.add(stop.channel.name);
+        // Armed before the RPC, because events can land while the RPC is in flight. A listener
+        // that is already up is what makes replaying the accumulated set unnecessary.
+        arm(explorerUiEvents);
+        for (const ch of collect)
+            arm(ch);
+        if (stop)
+            arm(stop.channel);
+        let settle;
+        let fail;
+        const outcome = new Promise((resolve, reject) => {
+            settle = resolve;
+            fail = reject;
+        });
+        const session = {
+            requestId,
+            ui,
+            correlationRequired: CONCURRENT_PANELS.includes(ui),
+            collect: collectNames,
+            watched,
+            until: stop ? { channel: stop.channel.name, $case: stop.$case } : undefined,
+            events: [],
+            timeoutMs: options?.timeoutMs,
+            elapsedMs: 0,
+            settled: false,
+            settle,
+            fail
+        };
+        sessions.set(requestId, session);
+        if (session.timeoutMs !== undefined)
+            ensureTimeoutSystem();
+        try {
+            const { openResult } = await openExplorerUiFn({ ui, requestId, itemPurchase });
+            // This call opened nothing, so no event carrying this request id is coming.
+            if (openResult !== OpenExplorerUiResult.OPENED) {
+                settleSession(session, { $case: 'notOpened', openResult });
+            }
+        }
+        catch (error) {
+            // Routed through the session rather than rethrown, so that `outcome` is never left
+            // pending and unobserved.
+            failSession(session, error);
+        }
+        return outcome;
+    }
+    // The implementation takes both argument forms and is blind to `collect`. The cast is what
+    // gives callers the two overloads that relate them.
+    return { openExplorerUiAndWait: openExplorerUiAndWait };
+}
+const helper = /* @__PURE__ */ create({ engine, openExplorerUi, explorerUiEvents: ExplorerUiEvents });
+/**
+ * Opens an explorer panel and waits for the session it started. The wait ends when the panel
+ * closes. See {@link WaitOptions} to collect events, to stop earlier or to bound the wait.
+ *
+ * Every lifecycle outcome resolves, see {@link WaitOutcome}. The promise rejects only when an
+ * event cannot be attributed to a call at all: an explorer too old to echo `request_id`
+ * paired with a panel that can coexist with another one.
+ *
+ * @public
+ */
+export const openExplorerUiAndWait = helper.openExplorerUiAndWait;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/explorer-ui/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  engine,\n  ExplorerItemPurchaseResult,\n  ExplorerUi,\n  ExplorerUiEventsResult,\n  GrowOnlyValueSetComponentDefinition,\n  IEngine,\n  PBExplorerItemPurchaseResult,\n  PBExplorerUiEventsResult\n} from '@dcl/ecs'\nimport { openExplorerUi, OpenExplorerUiResult } from '~system/RestrictedActions'\n\nexport { ExplorerUi, OpenExplorerUiResult }\n\n// What an explorer that does not echo request_id, or a user-initiated action, leaves on the wire.\nconst UNCORRELATED = 0\n\n// Panels that can be on screen next to another panel. The `ui` field alone cannot attribute\n// their events, so an event on one of these panels must carry a request_id.\nconst CONCURRENT_PANELS: readonly ExplorerUi[] = [ExplorerUi.EU_ITEM_PURCHASE]\n\n/** @public */\nexport type CorrelatedEvent = {\n  timestamp: number\n  requestId: number\n}\n\n/**\n * A named stream of events that this helper can collect and stop on.\n * @public\n */\nexport type Channel<N extends string = string, T extends CorrelatedEvent = CorrelatedEvent> = {\n  readonly name: N\n  readonly component: GrowOnlyValueSetComponentDefinition<T>\n}\n\n/** @public */\nexport type AnyChannel = Channel<string, any>\n\n/**\n * Wraps a grow-only result component as a {@link Channel}. The name must be unique within a scene.\n * @public\n */\nexport function channel<N extends string, T extends CorrelatedEvent>(\n  name: N,\n  component: GrowOnlyValueSetComponentDefinition<T>\n): Channel<N, T> {\n  return { name, component }\n}\n\n/** Panel lifecycle events: opened and closed. @public */\nexport const ExplorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult> = /* @__PURE__ */ channel(\n  'explorerUi',\n  ExplorerUiEventsResult\n)\n\n/** Outcome of an `EU_ITEM_PURCHASE` flow: purchased, dismissed or failed. @public */\nexport const ItemPurchase: Channel<'itemPurchase', PBExplorerItemPurchaseResult> = /* @__PURE__ */ channel(\n  'itemPurchase',\n  ExplorerItemPurchaseResult\n)\n\n/**\n * The `$case` names of a channel's event union.\n * @public\n */\nexport type CaseOf<C extends AnyChannel> =\n  C extends Channel<any, infer T> ? Extract<T[keyof T], { $case: string }>['$case'] : never\n\n/** @public */\nexport type Variant<C extends AnyChannel = AnyChannel, K extends string = string> = {\n  readonly channel: C\n  readonly $case: K\n}\n\n/** @public */\nexport function variant<C extends AnyChannel, K extends CaseOf<C>>(ch: C, $case: K): Variant<C, K> {\n  return { channel: ch, $case }\n}\n\n/**\n * What ends the wait before the panel closes: any event on a channel, or one `$case` of it.\n * @public\n */\nexport type StopCondition = AnyChannel | Variant\n\n/** @public */\nexport type Collected<C> = C extends Channel<infer N, infer T> ? { channel: N; event: T } : never\n\n/**\n * How the wait ended.\n * - `closed`: the panel this call opened was closed.\n * - `matched`: `until` fired first, so the panel may still be on screen.\n * - `notOpened`: this call did not open anything. `openResult` says why.\n * - `timedOut`: `timeoutMs` elapsed first.\n *\n * `events` always holds everything collected, the event that stopped the wait included.\n * @public\n */\nexport type WaitOutcome<C extends readonly AnyChannel[]> =\n  | { $case: 'closed'; events: readonly Collected<C[number]>[] }\n  | { $case: 'matched'; events: readonly Collected<C[number]>[] }\n  | { $case: 'notOpened'; openResult: OpenExplorerUiResult }\n  | { $case: 'timedOut'; events: readonly Collected<C[number]>[] }\n\n/** @public */\nexport type WaitOptions<C extends readonly AnyChannel[]> = {\n  /** Channels whose events land in `events`. Defaults to none. */\n  collect?: C\n  /** Stops the wait early. The panel closing always stops it regardless. */\n  until?: StopCondition\n  /**\n   * Bounds the wait, in milliseconds. On expiry the promise resolves with `$case: 'timedOut'`.\n   * No default, because a panel can stay open for minutes. Without it, an explorer that opens\n   * a panel and then emits no `closed` leaves the promise pending for the scene's whole life.\n   */\n  timeoutMs?: number\n}\n\n/** @public */\nexport type OpenExplorerUiRequest =\n  | { ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>; itemPurchase?: undefined }\n  | { ui: ExplorerUi.EU_ITEM_PURCHASE; itemPurchase: { urn: string } }\n\n/**\n * Signature of {@link openExplorerUiAndWait}. The second overload takes a bare `ui`, so a\n * computed panel value needs no narrowing.\n * @public\n */\nexport interface OpenExplorerUiAndWait {\n  <const C extends readonly AnyChannel[] = []>(\n    request: OpenExplorerUiRequest,\n    options?: WaitOptions<C>\n  ): Promise<WaitOutcome<C>>\n  (ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>): Promise<WaitOutcome<[]>>\n}\n\n/** @internal exposed for tests */\nexport const EXPLORER_UI_WAIT_TIMEOUT_SYSTEM = 'explorer-ui-wait-timeout'\n\n// Lowest priority sorts this system last, so when it removes itself mid-tick it splices the\n// last element of the array the engine is iterating and skips no other system.\nconst TIMEOUT_SYSTEM_PRIORITY = Number.MIN_SAFE_INTEGER\n\ntype OpenExplorerUiFn = (body: {\n  ui: ExplorerUi\n  requestId?: number\n  itemPurchase?: { urn: string }\n}) => Promise<{ openResult: OpenExplorerUiResult }>\n\ntype CollectedEvent = { channel: string; event: CorrelatedEvent }\n\ntype Session = {\n  requestId: number\n  ui: ExplorerUi\n  correlationRequired: boolean\n  collect: ReadonlySet<string>\n  watched: ReadonlySet<string>\n  until: { channel: string; $case: string | undefined } | undefined\n  events: CollectedEvent[]\n  timeoutMs: number | undefined\n  elapsedMs: number\n  settled: boolean\n  settle: (outcome: WaitOutcome<never[]>) => void\n  fail: (error: Error) => void\n}\n\ntype Attribution = 'yes' | 'no' | 'ambiguous'\n\n// ts-proto renders a `oneof` as one wrapper property `{ $case, [$case]: value }`. Finding that\n// property by shape keeps the helper independent of the name each message gave it: `event` on\n// one message, `status` on another.\nfunction caseOf(event: CorrelatedEvent): string | undefined {\n  for (const key of Object.keys(event)) {\n    const value = (event as unknown as Record<string, unknown>)[key]\n    if (value && typeof value === 'object' && typeof (value as { $case?: unknown }).$case === 'string') {\n      return (value as { $case: string }).$case\n    }\n  }\n  return undefined\n}\n\nfunction normalizeStop(stop: StopCondition): { channel: AnyChannel; $case: string | undefined } {\n  return '$case' in stop ? { channel: stop.channel, $case: stop.$case } : { channel: stop, $case: undefined }\n}\n\n/** @internal test seam. The production instance is {@link openExplorerUiAndWait}. */\nexport function create(deps: {\n  engine: IEngine\n  openExplorerUi: OpenExplorerUiFn\n  explorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult>\n}) {\n  const { engine: engineInstance, openExplorerUi: openExplorerUiFn, explorerUiEvents } = deps\n  const root = engineInstance.RootEntity\n\n  const sessions = new Map<number, Session>()\n  // Keyed by name, so two wrappers around the same component arm one listener, not two.\n  const armed = new Map<string, GrowOnlyValueSetComponentDefinition<any>>()\n  // Starts at 1 so a minted id never collides with UNCORRELATED.\n  let nextRequestId = 1\n  let timeoutSystemAdded = false\n\n  function arm(ch: AnyChannel) {\n    const bound = armed.get(ch.name)\n    if (bound) {\n      if (bound !== ch.component) {\n        throw new Error(\n          `openExplorerUiAndWait: channel name '${ch.name}' is already bound to a different component. ` +\n            `Channel names identify a stream, so they have to be unique within a scene.`\n        )\n      }\n      return\n    }\n    armed.set(ch.name, ch.component)\n    const name = ch.name\n    // onChange has no unsubscribe, so one listener per channel lives for the engine's lifetime.\n    ch.component.onChange(root, (value: CorrelatedEvent | undefined) => {\n      // `undefined` arrives on DELETE_ENTITY. Otherwise `value` is one appended element,\n      // not the whole set.\n      if (value) deliver(name, value)\n    })\n  }\n\n  function attribute(session: Session, name: string, event: CorrelatedEvent): Attribution {\n    if (event.requestId === session.requestId) return 'yes'\n    if (event.requestId !== UNCORRELATED) return 'no'\n    // Only the lifecycle channel carries a second discriminator, `ui`, and it identifies a\n    // session only while panels cannot coexist. A second call for the same panel is answered\n    // WAS_ALREADY_OPEN, so at most one session per non-concurrent panel is ever live.\n    if (session.correlationRequired || name !== explorerUiEvents.name) return 'ambiguous'\n    return (event as PBExplorerUiEventsResult).ui === session.ui ? 'yes' : 'no'\n  }\n\n  function deliver(name: string, event: CorrelatedEvent) {\n    // Settling deletes from `sessions` mid-iteration, which a Map tolerates. Nothing adds.\n    for (const session of sessions.values()) {\n      if (!session.watched.has(name)) continue\n      const attribution = attribute(session, name, event)\n      if (attribution === 'no') continue\n      if (attribution === 'ambiguous') {\n        failSession(\n          session,\n          new Error(\n            `openExplorerUiAndWait: got a '${name}' event with no request_id, and nothing else identifies ` +\n              `the call it belongs to. This explorer does not echo OpenExplorerUiRequest.request_id.`\n          )\n        )\n        continue\n      }\n      accept(session, name, event)\n    }\n  }\n\n  function accept(session: Session, name: string, event: CorrelatedEvent) {\n    if (session.collect.has(name)) session.events.push({ channel: name, event })\n\n    // The close is terminal and wins over `until`, because `matched` would tell the caller\n    // that the panel is still on screen.\n    if (name === explorerUiEvents.name && caseOf(event) === 'closed') {\n      settleSession(session, { $case: 'closed', events: session.events as never[] })\n      return\n    }\n\n    const until = session.until\n    if (!until || until.channel !== name) return\n    if (until.$case === undefined || until.$case === caseOf(event)) {\n      settleSession(session, { $case: 'matched', events: session.events as never[] })\n    }\n  }\n\n  function settleSession(session: Session, outcome: WaitOutcome<never[]>) {\n    if (session.settled) return\n    session.settled = true\n    sessions.delete(session.requestId)\n    session.settle(outcome)\n    maybeRemoveTimeoutSystem()\n  }\n\n  function failSession(session: Session, error: Error) {\n    if (session.settled) return\n    session.settled = true\n    sessions.delete(session.requestId)\n    session.fail(error)\n    maybeRemoveTimeoutSystem()\n  }\n\n  function hasTimedSession(): boolean {\n    for (const session of sessions.values()) {\n      if (session.timeoutMs !== undefined) return true\n    }\n    return false\n  }\n\n  function maybeRemoveTimeoutSystem() {\n    if (!timeoutSystemAdded || hasTimedSession()) return\n    timeoutSystemAdded = false\n    engineInstance.removeSystem(EXPLORER_UI_WAIT_TIMEOUT_SYSTEM)\n  }\n\n  function ensureTimeoutSystem() {\n    if (timeoutSystemAdded) return\n    timeoutSystemAdded = true\n    // The scene runtime has no timers, so elapsed time is accumulated from the engine's dt.\n    engineInstance.addSystem(\n      (dt: number) => {\n        for (const session of sessions.values()) {\n          if (session.timeoutMs === undefined) continue\n          session.elapsedMs += dt * 1000\n          if (session.elapsedMs >= session.timeoutMs) {\n            settleSession(session, { $case: 'timedOut', events: session.events as never[] })\n          }\n        }\n        maybeRemoveTimeoutSystem()\n      },\n      TIMEOUT_SYSTEM_PRIORITY,\n      EXPLORER_UI_WAIT_TIMEOUT_SYSTEM\n    )\n  }\n\n  async function openExplorerUiAndWait(\n    request: OpenExplorerUiRequest | Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>,\n    options?: WaitOptions<readonly AnyChannel[]>\n  ): Promise<WaitOutcome<never[]>> {\n    const { ui, itemPurchase } = typeof request === 'number' ? { ui: request, itemPurchase: undefined } : request\n    const requestId = nextRequestId++\n\n    const collect = options?.collect ?? []\n    const collectNames = new Set<string>()\n    for (const ch of collect) collectNames.add(ch.name)\n\n    const stop = options?.until ? normalizeStop(options.until) : undefined\n    const watched = new Set<string>(collectNames)\n    watched.add(explorerUiEvents.name)\n    if (stop) watched.add(stop.channel.name)\n\n    // Armed before the RPC, because events can land while the RPC is in flight. A listener\n    // that is already up is what makes replaying the accumulated set unnecessary.\n    arm(explorerUiEvents)\n    for (const ch of collect) arm(ch)\n    if (stop) arm(stop.channel)\n\n    let settle!: (outcome: WaitOutcome<never[]>) => void\n    let fail!: (error: Error) => void\n    const outcome = new Promise<WaitOutcome<never[]>>((resolve, reject) => {\n      settle = resolve\n      fail = reject\n    })\n\n    const session: Session = {\n      requestId,\n      ui,\n      correlationRequired: CONCURRENT_PANELS.includes(ui),\n      collect: collectNames,\n      watched,\n      until: stop ? { channel: stop.channel.name, $case: stop.$case } : undefined,\n      events: [],\n      timeoutMs: options?.timeoutMs,\n      elapsedMs: 0,\n      settled: false,\n      settle,\n      fail\n    }\n    sessions.set(requestId, session)\n    if (session.timeoutMs !== undefined) ensureTimeoutSystem()\n\n    try {\n      const { openResult } = await openExplorerUiFn({ ui, requestId, itemPurchase })\n      // This call opened nothing, so no event carrying this request id is coming.\n      if (openResult !== OpenExplorerUiResult.OPENED) {\n        settleSession(session, { $case: 'notOpened', openResult })\n      }\n    } catch (error) {\n      // Routed through the session rather than rethrown, so that `outcome` is never left\n      // pending and unobserved.\n      failSession(session, error as Error)\n    }\n\n    return outcome\n  }\n\n  // The implementation takes both argument forms and is blind to `collect`. The cast is what\n  // gives callers the two overloads that relate them.\n  return { openExplorerUiAndWait: openExplorerUiAndWait as OpenExplorerUiAndWait }\n}\n\nconst helper = /* @__PURE__ */ create({ engine, openExplorerUi, explorerUiEvents: ExplorerUiEvents })\n\n/**\n * Opens an explorer panel and waits for the session it started. The wait ends when the panel\n * closes. See {@link WaitOptions} to collect events, to stop earlier or to bound the wait.\n *\n * Every lifecycle outcome resolves, see {@link WaitOutcome}. The promise rejects only when an\n * event cannot be attributed to a call at all: an explorer too old to echo `request_id`\n * paired with a panel that can coexist with another one.\n *\n * @public\n */\nexport const openExplorerUiAndWait: OpenExplorerUiAndWait = helper.openExplorerUiAndWait\n"]}

package/internal/language-events.d.ts

@@ -0,0 +1 @@
+export {};

package/internal/language-events.js

@@ -0,0 +1,8 @@
+import { Observable } from './Observable';
+/**
+ * @internal
+ * Raw `localeChanged` events drained from the renderer by `pollEvents`.
+ * Kept side-effect free so `observables` doesn't load `platform` for every scene.
+ */
+export const localeChangedEvents = new Observable();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2UtZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVybmFsL2xhbmd1YWdlLWV2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBRXpDOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLFVBQVUsRUFBc0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICcuL09ic2VydmFibGUnXG5cbi8qKlxuICogQGludGVybmFsXG4gKiBSYXcgYGxvY2FsZUNoYW5nZWRgIGV2ZW50cyBkcmFpbmVkIGZyb20gdGhlIHJlbmRlcmVyIGJ5IGBwb2xsRXZlbnRzYC5cbiAqIEtlcHQgc2lkZS1lZmZlY3QgZnJlZSBzbyBgb2JzZXJ2YWJsZXNgIGRvZXNuJ3QgbG9hZCBgcGxhdGZvcm1gIGZvciBldmVyeSBzY2VuZS5cbiAqL1xuZXhwb3J0IGNvbnN0IGxvY2FsZUNoYW5nZWRFdmVudHMgPSBuZXcgT2JzZXJ2YWJsZTx7IGxvY2FsZTogc3RyaW5nIH0+KClcbiJdfQ==

package/observables.d.ts

@@ -29,6 +29,10 @@ export interface IEvents {
         sender: string;
         message: string;
     };
+    /** Triggered when the player switches the client language. `locale` is a BCP-47 tag */
+    localeChanged: {
+        locale: string;
+    };
     /**
      * This is triggered once the scene should start.
      */

package/observables.js

@@ -2,6 +2,7 @@ import { Observable } from './internal/Observable';
 import { AvatarBase, AvatarEmoteCommand, AvatarEquippedData, PlayerIdentityData, PointerEventsResult, RealmInfo, engine } from '@dcl/ecs';
 import { subscribe } from '~system/EngineApi';
 import players from './players';
+import { localeChangedEvents } from './internal/language-events';
 /**
  * @internal
  * This function generates a callback that is passed to the Observable
@@ -98,6 +99,10 @@ export async function pollEvents(sendBatch) {
                     onCommsMessage.notifyObservers(data);
                     break;
                 }
+                case 'localeChanged': {
+                    localeChangedEvents.notifyObservers(data);
+                    break;
+                }
             }
         }
     }
@@ -245,4 +250,4 @@ function processObservables() {
     engine.addSystem(observableSystem);
     return { subscribe };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observables.js","sourceRoot":"","sources":["src/observables.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from './internal/Observable'\nimport {\n  AvatarBase,\n  AvatarEmoteCommand,\n  AvatarEquippedData,\n  Entity,\n  PlayerIdentityData,\n  PointerEventsResult,\n  RealmInfo,\n  Vector3Type,\n  engine\n} from '@dcl/ecs'\nimport { ManyEntityAction, SendBatchResponse, subscribe } from '~system/EngineApi'\nimport players from './players'\n\n/// --- EVENTS ---\n\n/** @public */\nexport type IEventNames = keyof IEvents\n\n/**\n * @public\n * Note: Don't use `on` prefix for IEvents to avoid redundancy with `event.on(\"onEventName\")` syntax.\n */\nexport interface IEvents {\n  playerExpression: {\n    expressionId: string\n  }\n\n  /**\n   * This event gets triggered when the user enters the scene\n   */\n  onEnterScene: {\n    userId: string\n  }\n\n  /**\n   * This event gets triggered when the user leaves the scene\n   */\n  onLeaveScene: {\n    userId: string\n  }\n\n  /**\n   * This event gets triggered after receiving a comms message.\n   */\n  comms: {\n    sender: string\n    message: string\n  }\n\n  /**\n   * This is triggered once the scene should start.\n   */\n  sceneStart: unknown\n\n  /** This is triggered at least for each videoStatus change */\n  videoEvent: {\n    componentId: string\n    videoClipId: string\n    /** Status, can be NONE = 0, ERROR = 1, LOADING = 2, READY = 3, PLAYING = 4,BUFFERING = 5 */\n    videoStatus: number\n    /** Current offset position in seconds */\n    currentOffset: number\n    /** Video length in seconds. Can be -1 */\n    totalVideoLength: number\n  }\n\n  /** This is trigger everytime a profile is changed */\n  profileChanged: {\n    ethAddress: string\n    version: number\n  }\n\n  /** Triggered when peer's avatar is connected and visible */\n  playerConnected: {\n    userId: string\n  }\n\n  /** Triggered when peer disconnect and/or it avatar is set invisible by comms */\n  playerDisconnected: {\n    userId: string\n  }\n\n  /** Triggered when current realm or island changes */\n  onRealmChanged: {\n    domain: string\n    room: string\n    serverName: string\n    displayName: string\n  }\n\n  /** Triggered when other player's avatar is clicked */\n  playerClicked: {\n    userId: string\n    ray: {\n      origin: Vector3Type\n      direction: Vector3Type\n      distance: number\n    }\n  }\n}\n\n/**\n * @internal\n * This function generates a callback that is passed to the Observable\n * constructor to subscribe to the events of the DecentralandInterface\n */\nfunction createSubscriber(eventName: keyof IEvents) {\n  return () => {\n    if (eventName === 'comms') {\n      subscribe({ eventId: eventName }).catch(console.error)\n    } else {\n      SDK7ComponentsObservable?.subscribe(eventName)\n    }\n  }\n}\n\n/**\n * These events are triggered after your character enters the scene.\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onEnterSceneObservable = new Observable<IEvents['onEnterScene']>(createSubscriber('onEnterScene'))\n/** @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed. Use onEnterSceneObservable instead. */\nexport const onEnterScene = onEnterSceneObservable\n\n/**\n * These events are triggered after your character leaves the scene.\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onLeaveSceneObservable = new Observable<IEvents['onLeaveScene']>(createSubscriber('onLeaveScene'))\n\n/** @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed. Use onLeaveSceneObservable instead. */\nexport const onLeaveScene = onLeaveSceneObservable\n\n/**\n * This event is triggered after all the resources of the scene were loaded (models, textures, etc...)\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onSceneReadyObservable = new Observable<IEvents['sceneStart']>(createSubscriber('sceneStart'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerExpressionObservable = new Observable<IEvents['playerExpression']>(\n  createSubscriber('playerExpression')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onVideoEvent = new Observable<IEvents['videoEvent']>(createSubscriber('videoEvent'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onProfileChanged = new Observable<IEvents['profileChanged']>(createSubscriber('profileChanged'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerConnectedObservable = new Observable<IEvents['playerConnected']>(\n  createSubscriber('playerConnected')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerDisconnectedObservable = new Observable<IEvents['playerDisconnected']>(\n  createSubscriber('playerDisconnected')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onRealmChangedObservable = new Observable<IEvents['onRealmChanged']>(createSubscriber('onRealmChanged'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerClickedObservable = new Observable<IEvents['playerClicked']>(createSubscriber('playerClicked'))\n\n/**\n * @internal\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onCommsMessage = new Observable<IEvents['comms']>(createSubscriber('comms'))\n\n/**\n * @internal\n * @deprecated this is an OLD API.\n * This function uses the SDK6 sendBatch to poll events from the renderer\n */\nexport async function pollEvents(sendBatch: (body: ManyEntityAction) => Promise<SendBatchResponse>) {\n  const { events } = await sendBatch({ actions: [] })\n  for (const e of events) {\n    if (e.generic) {\n      const data = JSON.parse(e.generic.eventData)\n      switch (e.generic.eventId) {\n        case 'comms': {\n          onCommsMessage.notifyObservers(data as IEvents['comms'])\n          break\n        }\n      }\n    }\n  }\n}\n\nconst SDK7ComponentsObservable = processObservables()\nfunction processObservables() {\n  const subscriptions = new Set<keyof IEvents>()\n\n  function subscribe(eventName: keyof IEvents) {\n    if (subscriptions.has(eventName)) return\n    switch (eventName) {\n      case 'playerClicked': {\n        subscribePlayerClick()\n        break\n      }\n      case 'onEnterScene':\n      case 'playerConnected': {\n        subscribeEnterScene()\n        break\n      }\n      case 'onLeaveScene':\n      case 'playerDisconnected': {\n        subscribeLeaveScene()\n        break\n      }\n      case 'onRealmChanged': {\n        subscribeRealmChange()\n        break\n      }\n      case 'playerExpression': {\n        subscribePlayerExpression()\n        break\n      }\n      case 'profileChanged': {\n        subscribeProfileChange()\n        break\n      }\n    }\n    subscriptions.add(eventName)\n  }\n  /**\n   * PLAYER ENTER/CONNECTED observable\n   */\n  function subscribeEnterScene() {\n    players.onEnterScene((player) => {\n      if (subscriptions.has('onEnterScene')) {\n        onEnterSceneObservable.notifyObservers({ userId: player.userId })\n      }\n\n      if (subscriptions.has('playerConnected')) {\n        onPlayerConnectedObservable.notifyObservers({ userId: player.userId })\n      }\n    })\n  }\n  /**\n   * PLAYER LEAVE/DISCONNECTED observable\n   */\n  function subscribeLeaveScene() {\n    players.onLeaveScene((userId) => {\n      if (subscriptions.has('onLeaveScene')) {\n        onLeaveSceneObservable.notifyObservers({ userId })\n      }\n\n      if (subscriptions.has('playerDisconnected')) {\n        onPlayerDisconnectedObservable.notifyObservers({ userId })\n      }\n    })\n  }\n  /**\n   * REALM CHANGE observable\n   */\n  function subscribeRealmChange() {\n    RealmInfo.onChange(engine.RootEntity, (value) => {\n      if (value) {\n        onRealmChangedObservable.notifyObservers({\n          domain: value.baseUrl,\n          displayName: value.realmName,\n          room: value.room ?? '',\n          serverName: value.realmName\n        })\n      }\n    })\n  }\n  /**\n   * PLAYER/AVATAR CLICKED observable\n   */\n  function subscribePlayerClick() {\n    const playerEntities = new Set<Entity>()\n    engine.addSystem(() => {\n      for (const [entity] of engine.getEntitiesWith(PlayerIdentityData)) {\n        if (playerEntities.has(entity)) continue\n        playerEntities.add(entity)\n\n        PointerEventsResult.onChange(entity, (data) => {\n          if (data?.hit) {\n            onPlayerClickedObservable.notifyObservers({\n              userId: PlayerIdentityData.getOrNull(entity)?.address ?? '',\n              ray: {\n                direction: data.hit.direction!,\n                distance: data.hit.length,\n                origin: data.hit.globalOrigin!\n              }\n            })\n          }\n        })\n      }\n    })\n  }\n\n  /**\n   * Player expression observable\n   */\n  function subscribePlayerExpression() {\n    AvatarEmoteCommand.onChange(engine.PlayerEntity, (value) => {\n      onPlayerExpressionObservable.notifyObservers({ expressionId: value?.emoteUrn ?? '' })\n    })\n  }\n\n  /**\n   * PROFILE CHANGE observable\n   */\n  function subscribeProfileChange() {\n    AvatarBase.onChange(engine.PlayerEntity, () => {\n      if (!profileAddress) return\n      onProfileChanged.notifyObservers({ ethAddress: profileAddress, version: 0 })\n    })\n\n    AvatarEquippedData.onChange(engine.PlayerEntity, () => {\n      if (!profileAddress) return\n      onProfileChanged.notifyObservers({ ethAddress: profileAddress, version: 0 })\n    })\n  }\n\n  // Flag to call once the scene is initalized.\n  let sceneReady = false\n  let profileAddress: string | undefined\n\n  function observableSystem() {\n    if (sceneReady && profileAddress) {\n      return engine.removeSystem(observableSystem)\n    }\n    if (!sceneReady) {\n      sceneReady = true\n      onSceneReadyObservable.notifyObservers({})\n    }\n    if (profileAddress) return\n    profileAddress = PlayerIdentityData.getOrNull(engine.PlayerEntity)?.address\n  }\n\n  engine.addSystem(observableSystem)\n\n  return { subscribe }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observables.js","sourceRoot":"","sources":["src/observables.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from './internal/Observable'\nimport {\n  AvatarBase,\n  AvatarEmoteCommand,\n  AvatarEquippedData,\n  Entity,\n  PlayerIdentityData,\n  PointerEventsResult,\n  RealmInfo,\n  Vector3Type,\n  engine\n} from '@dcl/ecs'\nimport { ManyEntityAction, SendBatchResponse, subscribe } from '~system/EngineApi'\nimport players from './players'\nimport { localeChangedEvents } from './internal/language-events'\n\n/// --- EVENTS ---\n\n/** @public */\nexport type IEventNames = keyof IEvents\n\n/**\n * @public\n * Note: Don't use `on` prefix for IEvents to avoid redundancy with `event.on(\"onEventName\")` syntax.\n */\nexport interface IEvents {\n  playerExpression: {\n    expressionId: string\n  }\n\n  /**\n   * This event gets triggered when the user enters the scene\n   */\n  onEnterScene: {\n    userId: string\n  }\n\n  /**\n   * This event gets triggered when the user leaves the scene\n   */\n  onLeaveScene: {\n    userId: string\n  }\n\n  /**\n   * This event gets triggered after receiving a comms message.\n   */\n  comms: {\n    sender: string\n    message: string\n  }\n\n  /** Triggered when the player switches the client language. `locale` is a BCP-47 tag */\n  localeChanged: {\n    locale: string\n  }\n\n  /**\n   * This is triggered once the scene should start.\n   */\n  sceneStart: unknown\n\n  /** This is triggered at least for each videoStatus change */\n  videoEvent: {\n    componentId: string\n    videoClipId: string\n    /** Status, can be NONE = 0, ERROR = 1, LOADING = 2, READY = 3, PLAYING = 4,BUFFERING = 5 */\n    videoStatus: number\n    /** Current offset position in seconds */\n    currentOffset: number\n    /** Video length in seconds. Can be -1 */\n    totalVideoLength: number\n  }\n\n  /** This is trigger everytime a profile is changed */\n  profileChanged: {\n    ethAddress: string\n    version: number\n  }\n\n  /** Triggered when peer's avatar is connected and visible */\n  playerConnected: {\n    userId: string\n  }\n\n  /** Triggered when peer disconnect and/or it avatar is set invisible by comms */\n  playerDisconnected: {\n    userId: string\n  }\n\n  /** Triggered when current realm or island changes */\n  onRealmChanged: {\n    domain: string\n    room: string\n    serverName: string\n    displayName: string\n  }\n\n  /** Triggered when other player's avatar is clicked */\n  playerClicked: {\n    userId: string\n    ray: {\n      origin: Vector3Type\n      direction: Vector3Type\n      distance: number\n    }\n  }\n}\n\n/**\n * @internal\n * This function generates a callback that is passed to the Observable\n * constructor to subscribe to the events of the DecentralandInterface\n */\nfunction createSubscriber(eventName: keyof IEvents) {\n  return () => {\n    if (eventName === 'comms') {\n      subscribe({ eventId: eventName }).catch(console.error)\n    } else {\n      SDK7ComponentsObservable?.subscribe(eventName)\n    }\n  }\n}\n\n/**\n * These events are triggered after your character enters the scene.\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onEnterSceneObservable = new Observable<IEvents['onEnterScene']>(createSubscriber('onEnterScene'))\n/** @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed. Use onEnterSceneObservable instead. */\nexport const onEnterScene = onEnterSceneObservable\n\n/**\n * These events are triggered after your character leaves the scene.\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onLeaveSceneObservable = new Observable<IEvents['onLeaveScene']>(createSubscriber('onLeaveScene'))\n\n/** @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed. Use onLeaveSceneObservable instead. */\nexport const onLeaveScene = onLeaveSceneObservable\n\n/**\n * This event is triggered after all the resources of the scene were loaded (models, textures, etc...)\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onSceneReadyObservable = new Observable<IEvents['sceneStart']>(createSubscriber('sceneStart'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerExpressionObservable = new Observable<IEvents['playerExpression']>(\n  createSubscriber('playerExpression')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onVideoEvent = new Observable<IEvents['videoEvent']>(createSubscriber('videoEvent'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onProfileChanged = new Observable<IEvents['profileChanged']>(createSubscriber('profileChanged'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerConnectedObservable = new Observable<IEvents['playerConnected']>(\n  createSubscriber('playerConnected')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerDisconnectedObservable = new Observable<IEvents['playerDisconnected']>(\n  createSubscriber('playerDisconnected')\n)\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onRealmChangedObservable = new Observable<IEvents['onRealmChanged']>(createSubscriber('onRealmChanged'))\n\n/**\n * @public\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onPlayerClickedObservable = new Observable<IEvents['playerClicked']>(createSubscriber('playerClicked'))\n\n/**\n * @internal\n * @deprecated This function is an inheritance of ECS6, it's here temporary for the feature parity, please read the news and docs to know how handle when it's removed.\n */\nexport const onCommsMessage = new Observable<IEvents['comms']>(createSubscriber('comms'))\n\n/**\n * @internal\n * @deprecated this is an OLD API.\n * This function uses the SDK6 sendBatch to poll events from the renderer\n */\nexport async function pollEvents(sendBatch: (body: ManyEntityAction) => Promise<SendBatchResponse>) {\n  const { events } = await sendBatch({ actions: [] })\n  for (const e of events) {\n    if (e.generic) {\n      const data = JSON.parse(e.generic.eventData)\n      switch (e.generic.eventId) {\n        case 'comms': {\n          onCommsMessage.notifyObservers(data as IEvents['comms'])\n          break\n        }\n        case 'localeChanged': {\n          localeChangedEvents.notifyObservers(data as IEvents['localeChanged'])\n          break\n        }\n      }\n    }\n  }\n}\n\nconst SDK7ComponentsObservable = processObservables()\nfunction processObservables() {\n  const subscriptions = new Set<keyof IEvents>()\n\n  function subscribe(eventName: keyof IEvents) {\n    if (subscriptions.has(eventName)) return\n    switch (eventName) {\n      case 'playerClicked': {\n        subscribePlayerClick()\n        break\n      }\n      case 'onEnterScene':\n      case 'playerConnected': {\n        subscribeEnterScene()\n        break\n      }\n      case 'onLeaveScene':\n      case 'playerDisconnected': {\n        subscribeLeaveScene()\n        break\n      }\n      case 'onRealmChanged': {\n        subscribeRealmChange()\n        break\n      }\n      case 'playerExpression': {\n        subscribePlayerExpression()\n        break\n      }\n      case 'profileChanged': {\n        subscribeProfileChange()\n        break\n      }\n    }\n    subscriptions.add(eventName)\n  }\n  /**\n   * PLAYER ENTER/CONNECTED observable\n   */\n  function subscribeEnterScene() {\n    players.onEnterScene((player) => {\n      if (subscriptions.has('onEnterScene')) {\n        onEnterSceneObservable.notifyObservers({ userId: player.userId })\n      }\n\n      if (subscriptions.has('playerConnected')) {\n        onPlayerConnectedObservable.notifyObservers({ userId: player.userId })\n      }\n    })\n  }\n  /**\n   * PLAYER LEAVE/DISCONNECTED observable\n   */\n  function subscribeLeaveScene() {\n    players.onLeaveScene((userId) => {\n      if (subscriptions.has('onLeaveScene')) {\n        onLeaveSceneObservable.notifyObservers({ userId })\n      }\n\n      if (subscriptions.has('playerDisconnected')) {\n        onPlayerDisconnectedObservable.notifyObservers({ userId })\n      }\n    })\n  }\n  /**\n   * REALM CHANGE observable\n   */\n  function subscribeRealmChange() {\n    RealmInfo.onChange(engine.RootEntity, (value) => {\n      if (value) {\n        onRealmChangedObservable.notifyObservers({\n          domain: value.baseUrl,\n          displayName: value.realmName,\n          room: value.room ?? '',\n          serverName: value.realmName\n        })\n      }\n    })\n  }\n  /**\n   * PLAYER/AVATAR CLICKED observable\n   */\n  function subscribePlayerClick() {\n    const playerEntities = new Set<Entity>()\n    engine.addSystem(() => {\n      for (const [entity] of engine.getEntitiesWith(PlayerIdentityData)) {\n        if (playerEntities.has(entity)) continue\n        playerEntities.add(entity)\n\n        PointerEventsResult.onChange(entity, (data) => {\n          if (data?.hit) {\n            onPlayerClickedObservable.notifyObservers({\n              userId: PlayerIdentityData.getOrNull(entity)?.address ?? '',\n              ray: {\n                direction: data.hit.direction!,\n                distance: data.hit.length,\n                origin: data.hit.globalOrigin!\n              }\n            })\n          }\n        })\n      }\n    })\n  }\n\n  /**\n   * Player expression observable\n   */\n  function subscribePlayerExpression() {\n    AvatarEmoteCommand.onChange(engine.PlayerEntity, (value) => {\n      onPlayerExpressionObservable.notifyObservers({ expressionId: value?.emoteUrn ?? '' })\n    })\n  }\n\n  /**\n   * PROFILE CHANGE observable\n   */\n  function subscribeProfileChange() {\n    AvatarBase.onChange(engine.PlayerEntity, () => {\n      if (!profileAddress) return\n      onProfileChanged.notifyObservers({ ethAddress: profileAddress, version: 0 })\n    })\n\n    AvatarEquippedData.onChange(engine.PlayerEntity, () => {\n      if (!profileAddress) return\n      onProfileChanged.notifyObservers({ ethAddress: profileAddress, version: 0 })\n    })\n  }\n\n  // Flag to call once the scene is initalized.\n  let sceneReady = false\n  let profileAddress: string | undefined\n\n  function observableSystem() {\n    if (sceneReady && profileAddress) {\n      return engine.removeSystem(observableSystem)\n    }\n    if (!sceneReady) {\n      sceneReady = true\n      onSceneReadyObservable.notifyObservers({})\n    }\n    if (profileAddress) return\n    profileAddress = PlayerIdentityData.getOrNull(engine.PlayerEntity)?.address\n  }\n\n  engine.addSystem(observableSystem)\n\n  return { subscribe }\n}\n"]}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dcl/sdk",
   "description": "",
-  "version": "7.29.1-35901015152.commit-d1b7b96",
+  "version": "7.29.1-35917671376.commit-046b268",
   "author": "Decentraland",
   "dependencies": {
-    "@dcl/ecs": "7.29.1-35901015152.commit-d1b7b96",
+    "@dcl/ecs": "7.29.1-35917671376.commit-046b268",
     "@dcl/ecs-math": "2.1.0",
-    "@dcl/js-runtime": "7.29.1-35901015152.commit-d1b7b96",
-    "@dcl/react-ecs": "7.29.1-35901015152.commit-d1b7b96",
-    "@dcl/sdk-commands": "7.29.1-35901015152.commit-d1b7b96"
+    "@dcl/js-runtime": "7.29.1-35917671376.commit-046b268",
+    "@dcl/react-ecs": "7.29.1-35917671376.commit-046b268",
+    "@dcl/sdk-commands": "7.29.1-35917671376.commit-046b268"
   },
   "keywords": [],
   "license": "Apache-2.0",
@@ -33,5 +33,5 @@
   },
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
-  "commit": "d1b7b964cd184465c1b65118e47b5dc6be68a184"
+  "commit": "046b268beee66a9d2d67dda7834087a8052f4f9c"
 }

package/platform/index.d.ts

@@ -1,5 +1,21 @@
+import { Observable } from '../internal/Observable';
 export type Platform = 'mobile' | 'desktop' | 'web';
+/**
+ * Triggered when the player switches the client language mid-session.
+ * Older clients never emit it.
+ * @public
+ */
+export declare const onPlayerLanguageChanged: Observable<{
+    language: string;
+}>;
 export declare function getPlatform(): Platform | null;
 export declare function isMobile(): boolean;
 export declare function isDesktop(): boolean;
 export declare function isWeb(): boolean;
+/**
+ * Player's client language as a BCP-47 tag (e.g. `'es'`, `'pt-BR'`).
+ * Returns `'en'` until the explorer responds, and on clients that don't report a locale.
+ * Use `onPlayerLanguageChanged` to react to mid-session changes.
+ * @public
+ */
+export declare function getPlayerLanguage(): string;