Commit to actually checking in distributable files

Author: Kerrick Long

.gitignore

@@ -1,6 +1,3 @@
-# Compiled JavaScript
-dist
-
 # Logs
 logs
 *.log

dist/amd/talker.min.js.map

@@ -0,0 +1,2 @@
+export declare const TALKER_CONTENT_TYPE: string;
+export declare const TALKER_ERR_MSG_TIMEOUT: string;

dist/common_js/talker.min.js.map

@@ -0,0 +1,74 @@
+import { ManipulablePromise } from "./utils/manipulable-promise";
+import { IncomingMessage, OutgoingMessage, Stringifyable } from "./message";
+/**
+ * Talker
+ * Opens a communication line between this window and a remote window via postMessage.
+ */
+declare class Talker {
+    private readonly remoteWindow;
+    private readonly remoteOrigin;
+    private readonly localWindow;
+    timeout: number;
+    /**
+     * @property onMessage - Will be called with every non-handshake, non-response message from the remote window
+     */
+    onMessage?: (message: IncomingMessage) => void;
+    private readonly handshake;
+    private handshaken;
+    private latestId;
+    private readonly queue;
+    private readonly sent;
+    /**
+     * @param remoteWindow - The remote `window` object to post/receive messages to/from
+     * @param remoteOrigin - The protocol, host, and port you expect the remoteWindow to be
+     * @param localWindow - The local `window` object
+     */
+    constructor(remoteWindow: Window, remoteOrigin: string, localWindow?: Window);
+    /**
+     * @param namespace - The namespace the message is in
+     * @param data - The data to send
+     * @param responseToId - If this is a response to a previous message, its ID.
+     */
+    send(namespace: string, data: Stringifyable, responseToId?: number | null): ManipulablePromise<IncomingMessage | Error>;
+    /**
+     * This is not marked private because other Talker-related classes need access to it,
+     * but your application code should probably avoid calling this method.
+     */
+    nextId(): number;
+    private receiveMessage;
+    /**
+     * Determines whether it is safe and appropriate to parse a postMessage messageEvent
+     * @param source - "source" property from the postMessage event
+     * @param origin - Protocol, host, and port
+     * @param type - Internet Media Type
+     */
+    private isSafeMessage;
+    private handleHandshake;
+    private handleMessage;
+    /**
+     * @param id - Message ID of the waiting promise
+     * @param message - Message that is responding to that ID
+     */
+    private respondToMessage;
+    /**
+     * Send a non-response message to awaiting hooks/callbacks
+     * @param message - Message that arrived
+     */
+    private broadcastMessage;
+    /**
+     * Send a handshake message to the remote window
+     * @param confirmation - Is this a confirmation handshake?
+     */
+    private sendHandshake;
+    /**
+     * Wrapper around window.postMessage to only send if we have the necessary objects
+     */
+    private postMessage;
+    /**
+     * Flushes the internal queue of outgoing messages, sending each one.
+     * Does nothing if Talker has not handshaken with the remote.
+     */
+    private flushQueue;
+}
+export { IncomingMessage, OutgoingMessage };
+export default Talker;

dist/constants.d.ts

@@ -0,0 +1,49 @@
+import { Promise } from "es6-promise";
+import Talker from "./index";
+declare abstract class Message {
+    protected readonly talker: Talker;
+    readonly namespace: string;
+    readonly data: Stringifyable;
+    readonly responseToId: number | null;
+    protected readonly type: string;
+    constructor(talker: Talker, namespace: string, data: Stringifyable, responseToId?: number | null);
+}
+export interface JSONableMessage {
+    readonly namespace?: string;
+    readonly data?: Stringifyable;
+    readonly id?: number;
+    readonly responseToId?: number;
+    readonly type: string;
+    readonly handshake?: boolean;
+    readonly handshakeConfirmation?: boolean;
+}
+export interface Stringifyable {
+    [index: string]: string | number | Stringifyable | Stringifyable[] | boolean | null | undefined;
+}
+export declare class OutgoingMessage extends Message {
+    protected readonly talker: Talker;
+    readonly namespace: string;
+    readonly data: Stringifyable;
+    readonly responseToId: number | null;
+    readonly id: number;
+    /**
+     * @param talker
+     * @param namespace
+     * @param data
+     * @param responseToId - If this is a response to a previous message, its ID.
+     */
+    constructor(talker: Talker, namespace: string, data: Stringifyable, responseToId?: number | null);
+    toJSON(): JSONableMessage;
+}
+export declare class IncomingMessage extends Message {
+    protected readonly talker: Talker;
+    readonly namespace: string;
+    readonly data: Stringifyable;
+    readonly id: number;
+    constructor(talker: Talker, namespace?: string, data?: Stringifyable, id?: number);
+    /**
+     * Please note that this response message will use the same timeout as Talker#send.
+     */
+    respond(data: Stringifyable): Promise<IncomingMessage | Error>;
+}
+export {};