@data-loom/realtime-js 0.0.2-alpha.2 → 0.0.2

package/dist/module/RealtimeClient.d.ts

@@ -0,0 +1,197 @@
+import type { WebSocket as WSWebSocket } from 'ws';
+import { CONNECTION_STATE, LOG_LEVEL } from './utils/constants';
+import Serializer from './utils/serializer';
+import Timer from './utils/timer';
+import RealtimeChannel from './RealtimeChannel';
+import type { RealtimeChannelOptions } from './RealtimeChannel';
+type Fetch = typeof fetch;
+export type Channel = {
+    name: string;
+    inserted_at: string;
+    updated_at: string;
+    id: number;
+};
+export type LogLevel = LOG_LEVEL;
+export type RealtimeMessage = {
+    topic: string;
+    event: string;
+    payload: any;
+    ref: string;
+    join_ref?: string;
+};
+export type RealtimeRemoveChannelResponse = 'ok' | 'timed out' | 'error';
+export interface WebSocketLikeConstructor {
+    new (address: string | URL, _ignored?: any, options?: {
+        headers: Object | undefined;
+    }): WebSocketLike;
+}
+export type WebSocketLike = WebSocket | WSWebSocket | WSWebSocketDummy;
+export interface WebSocketLikeError {
+    error: any;
+    message: string;
+    type: string;
+}
+export type RealtimeClientOptions = {
+    transport?: WebSocketLikeConstructor;
+    timeout?: number;
+    heartbeatIntervalMs?: number;
+    logger?: Function;
+    encode?: Function;
+    decode?: Function;
+    reconnectAfterMs?: Function;
+    headers?: {
+        [key: string]: string;
+    };
+    params?: {
+        [key: string]: any;
+    };
+    log_level?: LogLevel;
+    logLevel?: LogLevel;
+    fetch?: Fetch;
+    worker?: boolean;
+    workerUrl?: string;
+    accessToken?: () => Promise<string | null>;
+};
+export default class RealtimeClient {
+    accessTokenValue: string | null;
+    apiKey: string | null;
+    channels: RealtimeChannel[];
+    endPoint: string;
+    httpEndpoint: string;
+    headers?: {
+        [key: string]: string;
+    };
+    params?: {
+        [key: string]: string;
+    };
+    timeout: number;
+    transport: WebSocketLikeConstructor | null;
+    heartbeatIntervalMs: number;
+    heartbeatTimer: ReturnType<typeof setInterval> | undefined;
+    pendingHeartbeatRef: string | null;
+    ref: number;
+    reconnectTimer: Timer;
+    logger: Function;
+    logLevel?: LogLevel;
+    encode: Function;
+    decode: Function;
+    reconnectAfterMs: Function;
+    conn: WebSocketLike | null;
+    sendBuffer: Function[];
+    serializer: Serializer;
+    stateChangeCallbacks: {
+        open: Function[];
+        close: Function[];
+        error: Function[];
+        message: Function[];
+    };
+    fetch: Fetch;
+    accessToken: (() => Promise<string | null>) | null;
+    worker?: boolean;
+    workerUrl?: string;
+    workerRef?: Worker;
+    /**
+     * Initializes the Socket.
+     *
+     * @param endPoint The string WebSocket endpoint, ie, "ws://example.com/socket", "wss://example.com", "/socket" (inherited host & protocol)
+     * @param httpEndpoint The string HTTP endpoint, ie, "https://example.com", "/" (inherited host & protocol)
+     * @param options.transport The Websocket Transport, for example WebSocket. This can be a custom implementation
+     * @param options.timeout The default timeout in milliseconds to trigger push timeouts.
+     * @param options.params The optional params to pass when connecting.
+     * @param options.headers The optional headers to pass when connecting.
+     * @param options.heartbeatIntervalMs The millisec interval to send a heartbeat message.
+     * @param options.logger The optional function for specialized logging, ie: logger: (kind, msg, data) => { console.log(`${kind}: ${msg}`, data) }
+     * @param options.logLevel Sets the log level for Realtime
+     * @param options.encode The function to encode outgoing messages. Defaults to JSON: (payload, callback) => callback(JSON.stringify(payload))
+     * @param options.decode The function to decode incoming messages. Defaults to Serializer's decode.
+     * @param options.reconnectAfterMs he optional function that returns the millsec reconnect interval. Defaults to stepped backoff off.
+     * @param options.worker Use Web Worker to set a side flow. Defaults to false.
+     * @param options.workerUrl The URL of the worker script. Defaults to https://realtime.supabase.com/worker.js that includes a heartbeat event call to keep the connection alive.
+     */
+    constructor(endPoint: string, options?: RealtimeClientOptions);
+    /**
+     * Connects the socket, unless already connected.
+     */
+    connect(): void;
+    /**
+     * Returns the URL of the websocket.
+     * @returns string The URL of the websocket.
+     */
+    endpointURL(): string;
+    /**
+     * Disconnects the socket.
+     *
+     * @param code A numeric status code to send on disconnect.
+     * @param reason A custom reason for the disconnect.
+     */
+    disconnect(code?: number, reason?: string): void;
+    /**
+     * Returns all created channels
+     */
+    getChannels(): RealtimeChannel[];
+    /**
+     * Unsubscribes and removes a single channel
+     * @param channel A RealtimeChannel instance
+     */
+    removeChannel(channel: RealtimeChannel): Promise<RealtimeRemoveChannelResponse>;
+    /**
+     * Unsubscribes and removes all channels
+     */
+    removeAllChannels(): Promise<RealtimeRemoveChannelResponse[]>;
+    /**
+     * Logs the message.
+     *
+     * For customized logging, `this.logger` can be overridden.
+     */
+    log(kind: string, msg: string, data?: any): void;
+    /**
+     * Returns the current state of the socket.
+     */
+    connectionState(): CONNECTION_STATE;
+    /**
+     * Returns `true` is the connection is open.
+     */
+    isConnected(): boolean;
+    channel(topic: string, params?: RealtimeChannelOptions): RealtimeChannel;
+    /**
+     * Push out a message if the socket is connected.
+     *
+     * If the socket is not connected, the message gets enqueued within a local buffer, and sent out when a connection is next established.
+     */
+    push(data: RealtimeMessage): void;
+    /**
+     * Sets the JWT access token used for channel subscription authorization and Realtime RLS.
+     *
+     * If param is null it will use the `accessToken` callback function or the token set on the client.
+     *
+     * On callback used, it will set the value of the token internal to the client.
+     *
+     * @param token A JWT string to override the token set on the client.
+     */
+    setAuth(token?: string | null): Promise<void>;
+    /**
+     * Sends a heartbeat message if the socket is connected.
+     */
+    sendHeartbeat(): Promise<void>;
+    /**
+     * Flushes send buffer
+     */
+    flushSendBuffer(): void;
+    private _workerObjectUrl;
+}
+declare class WSWebSocketDummy {
+    binaryType: string;
+    close: Function;
+    onclose: Function;
+    onerror: Function;
+    onmessage: Function;
+    onopen: Function;
+    readyState: number;
+    send: Function;
+    url: string | URL | null;
+    constructor(address: string, _protocols: undefined, options: {
+        close: Function;
+    });
+}
+export {};
+//# sourceMappingURL=RealtimeClient.d.ts.map

package/dist/module/RealtimeClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealtimeClient.d.ts","sourceRoot":"","sources":["../../src/RealtimeClient.ts"],"names":[],"mappings":"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"}

package/dist/module/RealtimeClient.js

@@ -0,0 +1,482 @@
+import { CHANNEL_EVENTS, CONNECTION_STATE, DEFAULT_HEADERS, DEFAULT_TIMEOUT, SOCKET_STATES, TRANSPORTS, VSN, WS_CLOSE_NORMAL, } from './utils/constants';
+import Serializer from './utils/serializer';
+import Timer from './utils/timer';
+import { httpEndpointURL } from './utils/transformers';
+import RealtimeChannel from './RealtimeChannel';
+const noop = () => { };
+const NATIVE_WEBSOCKET_AVAILABLE = typeof WebSocket !== 'undefined';
+const WORKER_SCRIPT = `
+  addEventListener("message", (e) => {
+    if (e.data.event === "start") {
+      setInterval(() => postMessage({ event: "keepAlive" }), e.data.interval);
+    }
+  });`;
+export default class RealtimeClient {
+    /**
+     * Initializes the Socket.
+     *
+     * @param endPoint The string WebSocket endpoint, ie, "ws://example.com/socket", "wss://example.com", "/socket" (inherited host & protocol)
+     * @param httpEndpoint The string HTTP endpoint, ie, "https://example.com", "/" (inherited host & protocol)
+     * @param options.transport The Websocket Transport, for example WebSocket. This can be a custom implementation
+     * @param options.timeout The default timeout in milliseconds to trigger push timeouts.
+     * @param options.params The optional params to pass when connecting.
+     * @param options.headers The optional headers to pass when connecting.
+     * @param options.heartbeatIntervalMs The millisec interval to send a heartbeat message.
+     * @param options.logger The optional function for specialized logging, ie: logger: (kind, msg, data) => { console.log(`${kind}: ${msg}`, data) }
+     * @param options.logLevel Sets the log level for Realtime
+     * @param options.encode The function to encode outgoing messages. Defaults to JSON: (payload, callback) => callback(JSON.stringify(payload))
+     * @param options.decode The function to decode incoming messages. Defaults to Serializer's decode.
+     * @param options.reconnectAfterMs he optional function that returns the millsec reconnect interval. Defaults to stepped backoff off.
+     * @param options.worker Use Web Worker to set a side flow. Defaults to false.
+     * @param options.workerUrl The URL of the worker script. Defaults to https://realtime.supabase.com/worker.js that includes a heartbeat event call to keep the connection alive.
+     */
+    constructor(endPoint, options) {
+        var _a;
+        this.accessTokenValue = null;
+        this.apiKey = null;
+        this.channels = [];
+        this.endPoint = '';
+        this.httpEndpoint = '';
+        this.headers = DEFAULT_HEADERS;
+        this.params = {};
+        this.timeout = DEFAULT_TIMEOUT;
+        this.heartbeatIntervalMs = 25000;
+        this.heartbeatTimer = undefined;
+        this.pendingHeartbeatRef = null;
+        this.ref = 0;
+        this.logger = noop;
+        this.conn = null;
+        this.sendBuffer = [];
+        this.serializer = new Serializer();
+        this.stateChangeCallbacks = {
+            open: [],
+            close: [],
+            error: [],
+            message: [],
+        };
+        this.accessToken = null;
+        /**
+         * Use either custom fetch, if provided, or default fetch to make HTTP requests
+         *
+         * @internal
+         */
+        this._resolveFetch = (customFetch) => {
+            let _fetch;
+            if (customFetch) {
+                _fetch = customFetch;
+            }
+            else if (typeof fetch === 'undefined') {
+                _fetch = (...args) => import('@data-loom/node-fetch').then(({ default: fetch }) => fetch(...args));
+            }
+            else {
+                _fetch = fetch;
+            }
+            return (...args) => _fetch(...args);
+        };
+        this.endPoint = `${endPoint}/${TRANSPORTS.websocket}`;
+        this.httpEndpoint = httpEndpointURL(endPoint);
+        if (options === null || options === void 0 ? void 0 : options.transport) {
+            this.transport = options.transport;
+        }
+        else {
+            this.transport = null;
+        }
+        if (options === null || options === void 0 ? void 0 : options.params)
+            this.params = options.params;
+        if (options === null || options === void 0 ? void 0 : options.headers)
+            this.headers = Object.assign(Object.assign({}, this.headers), options.headers);
+        if (options === null || options === void 0 ? void 0 : options.timeout)
+            this.timeout = options.timeout;
+        if (options === null || options === void 0 ? void 0 : options.logger)
+            this.logger = options.logger;
+        if ((options === null || options === void 0 ? void 0 : options.logLevel) || (options === null || options === void 0 ? void 0 : options.log_level)) {
+            this.logLevel = options.logLevel || options.log_level;
+            this.params = Object.assign(Object.assign({}, this.params), { log_level: this.logLevel });
+        }
+        if (options === null || options === void 0 ? void 0 : options.heartbeatIntervalMs)
+            this.heartbeatIntervalMs = options.heartbeatIntervalMs;
+        const accessTokenValue = (_a = options === null || options === void 0 ? void 0 : options.params) === null || _a === void 0 ? void 0 : _a.apikey;
+        if (accessTokenValue) {
+            this.accessTokenValue = accessTokenValue;
+            this.apiKey = accessTokenValue;
+        }
+        this.reconnectAfterMs = (options === null || options === void 0 ? void 0 : options.reconnectAfterMs)
+            ? options.reconnectAfterMs
+            : (tries) => {
+                return [1000, 2000, 5000, 10000][tries - 1] || 10000;
+            };
+        this.encode = (options === null || options === void 0 ? void 0 : options.encode)
+            ? options.encode
+            : (payload, callback) => {
+                return callback(JSON.stringify(payload));
+            };
+        this.decode = (options === null || options === void 0 ? void 0 : options.decode)
+            ? options.decode
+            : this.serializer.decode.bind(this.serializer);
+        this.reconnectTimer = new Timer(async () => {
+            this.disconnect();
+            this.connect();
+        }, this.reconnectAfterMs);
+        this.fetch = this._resolveFetch(options === null || options === void 0 ? void 0 : options.fetch);
+        if (options === null || options === void 0 ? void 0 : options.worker) {
+            if (typeof window !== 'undefined' && !window.Worker) {
+                throw new Error('Web Worker is not supported');
+            }
+            this.worker = (options === null || options === void 0 ? void 0 : options.worker) || false;
+            this.workerUrl = options === null || options === void 0 ? void 0 : options.workerUrl;
+        }
+        this.accessToken = (options === null || options === void 0 ? void 0 : options.accessToken) || null;
+    }
+    /**
+     * Connects the socket, unless already connected.
+     */
+    connect() {
+        if (this.conn) {
+            return;
+        }
+        if (this.transport) {
+            this.conn = new this.transport(this.endpointURL(), undefined, {
+                headers: this.headers,
+            });
+            this.setupConnection();
+            return;
+        }
+        if (NATIVE_WEBSOCKET_AVAILABLE) {
+            this.conn = new WebSocket(this.endpointURL());
+            this.setupConnection();
+            return;
+        }
+        this.conn = new WSWebSocketDummy(this.endpointURL(), undefined, {
+            close: () => {
+                this.conn = null;
+            },
+        });
+        import('ws').then(({ default: WS }) => {
+            this.conn = new WS(this.endpointURL(), undefined, {
+                headers: this.headers,
+            });
+            this.setupConnection();
+        });
+    }
+    /**
+     * Returns the URL of the websocket.
+     * @returns string The URL of the websocket.
+     */
+    endpointURL() {
+        return this._appendParams(this.endPoint, Object.assign({}, this.params, { vsn: VSN }));
+    }
+    /**
+     * Disconnects the socket.
+     *
+     * @param code A numeric status code to send on disconnect.
+     * @param reason A custom reason for the disconnect.
+     */
+    disconnect(code, reason) {
+        if (this.conn) {
+            this.conn.onclose = function () { }; // noop
+            if (code) {
+                this.conn.close(code, reason !== null && reason !== void 0 ? reason : '');
+            }
+            else {
+                this.conn.close();
+            }
+            this.conn = null;
+            // remove open handles
+            this.heartbeatTimer && clearInterval(this.heartbeatTimer);
+            this.reconnectTimer.reset();
+        }
+    }
+    /**
+     * Returns all created channels
+     */
+    getChannels() {
+        return this.channels;
+    }
+    /**
+     * Unsubscribes and removes a single channel
+     * @param channel A RealtimeChannel instance
+     */
+    async removeChannel(channel) {
+        const status = await channel.unsubscribe();
+        if (this.channels.length === 0) {
+            this.disconnect();
+        }
+        return status;
+    }
+    /**
+     * Unsubscribes and removes all channels
+     */
+    async removeAllChannels() {
+        const values_1 = await Promise.all(this.channels.map((channel) => channel.unsubscribe()));
+        this.disconnect();
+        return values_1;
+    }
+    /**
+     * Logs the message.
+     *
+     * For customized logging, `this.logger` can be overridden.
+     */
+    log(kind, msg, data) {
+        this.logger(kind, msg, data);
+    }
+    /**
+     * Returns the current state of the socket.
+     */
+    connectionState() {
+        switch (this.conn && this.conn.readyState) {
+            case SOCKET_STATES.connecting:
+                return CONNECTION_STATE.Connecting;
+            case SOCKET_STATES.open:
+                return CONNECTION_STATE.Open;
+            case SOCKET_STATES.closing:
+                return CONNECTION_STATE.Closing;
+            default:
+                return CONNECTION_STATE.Closed;
+        }
+    }
+    /**
+     * Returns `true` is the connection is open.
+     */
+    isConnected() {
+        return this.connectionState() === CONNECTION_STATE.Open;
+    }
+    channel(topic, params = { config: {} }) {
+        const chan = new RealtimeChannel(`realtime:${topic}`, params, this);
+        this.channels.push(chan);
+        return chan;
+    }
+    /**
+     * Push out a message if the socket is connected.
+     *
+     * If the socket is not connected, the message gets enqueued within a local buffer, and sent out when a connection is next established.
+     */
+    push(data) {
+        const { topic, event, payload, ref } = data;
+        const callback = () => {
+            this.encode(data, (result) => {
+                var _a;
+                (_a = this.conn) === null || _a === void 0 ? void 0 : _a.send(result);
+            });
+        };
+        this.log('push', `${topic} ${event} (${ref})`, payload);
+        if (this.isConnected()) {
+            callback();
+        }
+        else {
+            this.sendBuffer.push(callback);
+        }
+    }
+    /**
+     * Sets the JWT access token used for channel subscription authorization and Realtime RLS.
+     *
+     * If param is null it will use the `accessToken` callback function or the token set on the client.
+     *
+     * On callback used, it will set the value of the token internal to the client.
+     *
+     * @param token A JWT string to override the token set on the client.
+     */
+    async setAuth(token = null) {
+        let tokenToSend = token ||
+            (this.accessToken && (await this.accessToken())) ||
+            this.accessTokenValue;
+        if (this.accessTokenValue != tokenToSend) {
+            this.accessTokenValue = tokenToSend;
+            this.channels.forEach((channel) => {
+                tokenToSend &&
+                    channel.updateJoinPayload({
+                        access_token: tokenToSend,
+                        version: this.headers && this.headers['X-Client-Info'],
+                    });
+                if (channel.joinedOnce && channel._isJoined()) {
+                    channel._push(CHANNEL_EVENTS.access_token, {
+                        access_token: tokenToSend,
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Sends a heartbeat message if the socket is connected.
+     */
+    async sendHeartbeat() {
+        var _a;
+        if (!this.isConnected()) {
+            return;
+        }
+        if (this.pendingHeartbeatRef) {
+            this.pendingHeartbeatRef = null;
+            this.log('transport', 'heartbeat timeout. Attempting to re-establish connection');
+            (_a = this.conn) === null || _a === void 0 ? void 0 : _a.close(WS_CLOSE_NORMAL, 'hearbeat timeout');
+            return;
+        }
+        this.pendingHeartbeatRef = this._makeRef();
+        this.push({
+            topic: 'phoenix',
+            event: 'heartbeat',
+            payload: {},
+            ref: this.pendingHeartbeatRef,
+        });
+        await this.setAuth();
+    }
+    /**
+     * Flushes send buffer
+     */
+    flushSendBuffer() {
+        if (this.isConnected() && this.sendBuffer.length > 0) {
+            this.sendBuffer.forEach((callback) => callback());
+            this.sendBuffer = [];
+        }
+    }
+    /**
+     * Return the next message ref, accounting for overflows
+     *
+     * @internal
+     */
+    _makeRef() {
+        let newRef = this.ref + 1;
+        if (newRef === this.ref) {
+            this.ref = 0;
+        }
+        else {
+            this.ref = newRef;
+        }
+        return this.ref.toString();
+    }
+    /**
+     * Unsubscribe from channels with the specified topic.
+     *
+     * @internal
+     */
+    _leaveOpenTopic(topic) {
+        let dupChannel = this.channels.find((c) => c.topic === topic && (c._isJoined() || c._isJoining()));
+        if (dupChannel) {
+            this.log('transport', `leaving duplicate topic "${topic}"`);
+            dupChannel.unsubscribe();
+        }
+    }
+    /**
+     * Removes a subscription from the socket.
+     *
+     * @param channel An open subscription.
+     *
+     * @internal
+     */
+    _remove(channel) {
+        this.channels = this.channels.filter((c) => c._joinRef() !== channel._joinRef());
+    }
+    /**
+     * Sets up connection handlers.
+     *
+     * @internal
+     */
+    setupConnection() {
+        if (this.conn) {
+            this.conn.binaryType = 'arraybuffer';
+            this.conn.onopen = () => this._onConnOpen();
+            this.conn.onerror = (error) => this._onConnError(error);
+            this.conn.onmessage = (event) => this._onConnMessage(event);
+            this.conn.onclose = (event) => this._onConnClose(event);
+        }
+    }
+    /** @internal */
+    _onConnMessage(rawMessage) {
+        this.decode(rawMessage.data, (msg) => {
+            let { topic, event, payload, ref } = msg;
+            if (ref && ref === this.pendingHeartbeatRef) {
+                this.pendingHeartbeatRef = null;
+            }
+            this.log('receive', `${payload.status || ''} ${topic} ${event} ${(ref && '(' + ref + ')') || ''}`, payload);
+            this.channels
+                .filter((channel) => channel._isMember(topic))
+                .forEach((channel) => channel._trigger(event, payload, ref));
+            this.stateChangeCallbacks.message.forEach((callback) => callback(msg));
+        });
+    }
+    /** @internal */
+    async _onConnOpen() {
+        this.log('transport', `connected to ${this.endpointURL()}`);
+        this.flushSendBuffer();
+        this.reconnectTimer.reset();
+        if (!this.worker) {
+            this.heartbeatTimer && clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+        }
+        else {
+            if (this.workerUrl) {
+                this.log('worker', `starting worker for from ${this.workerUrl}`);
+            }
+            else {
+                this.log('worker', `starting default worker`);
+            }
+            const objectUrl = this._workerObjectUrl(this.workerUrl);
+            this.workerRef = new Worker(objectUrl);
+            this.workerRef.onerror = (error) => {
+                this.log('worker', 'worker error', error.message);
+                this.workerRef.terminate();
+            };
+            this.workerRef.onmessage = (event) => {
+                if (event.data.event === 'keepAlive') {
+                    this.sendHeartbeat();
+                }
+            };
+            this.workerRef.postMessage({
+                event: 'start',
+                interval: this.heartbeatIntervalMs,
+            });
+        }
+        this.stateChangeCallbacks.open.forEach((callback) => callback());
+    }
+    /** @internal */
+    _onConnClose(event) {
+        this.log('transport', 'close', event);
+        this._triggerChanError();
+        this.heartbeatTimer && clearInterval(this.heartbeatTimer);
+        this.reconnectTimer.scheduleTimeout();
+        this.stateChangeCallbacks.close.forEach((callback) => callback(event));
+    }
+    /** @internal */
+    _onConnError(error) {
+        this.log('transport', error.message);
+        this._triggerChanError();
+        this.stateChangeCallbacks.error.forEach((callback) => callback(error));
+    }
+    /** @internal */
+    _triggerChanError() {
+        this.channels.forEach((channel) => channel._trigger(CHANNEL_EVENTS.error));
+    }
+    /** @internal */
+    _appendParams(url, params) {
+        if (Object.keys(params).length === 0) {
+            return url;
+        }
+        const prefix = url.match(/\?/) ? '&' : '?';
+        const query = new URLSearchParams(params);
+        return `${url}${prefix}${query}`;
+    }
+    _workerObjectUrl(url) {
+        let result_url;
+        if (url) {
+            result_url = url;
+        }
+        else {
+            const blob = new Blob([WORKER_SCRIPT], { type: 'application/javascript' });
+            result_url = URL.createObjectURL(blob);
+        }
+        return result_url;
+    }
+}
+class WSWebSocketDummy {
+    constructor(address, _protocols, options) {
+        this.binaryType = 'arraybuffer';
+        this.onclose = () => { };
+        this.onerror = () => { };
+        this.onmessage = () => { };
+        this.onopen = () => { };
+        this.readyState = SOCKET_STATES.connecting;
+        this.send = () => { };
+        this.url = null;
+        this.url = address;
+        this.close = options.close;
+    }
+}
+//# sourceMappingURL=RealtimeClient.js.map