@stripe/connect-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Stripe, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# Connect.js ES Module
+
+The [Connect.js library](https://stripe.com/docs/connect/get-started-connect-embedded-components) and its supporting API allows you to add connected account dashboard functionality to your website.
+This NPM package contains initialization logic for Connect embedded components along with related types.
+
+Note: Connect embedded components is currently still in beta. Please [contact us](https://stripe.com/docs/connect/get-started-connect-embedded-components#access) to request beta access.
+
+## Installation
+
+Use `npm` to install the Connect.js module:
+
+```sh
+npm install @stripe/connect-js
+```
+
+## Documentation
+
+- [Connect embedded components](https://stripe.com/docs/connect/get-started-connect-embedded-uis)
+- [Quickstart guide](https://stripe.com/docs/connect/connect-embedded-uis/quickstart)
+
+## Usage
+
+### `loadConnect`
+
+This function returns a `Promise` that resolves with a newly created `StripeConnect`
+object once Connect.js has loaded. If necessary, it will load Connect.js for you by inserting the Connect.js script tag.
+
+The `stripeConnect.initialize` function returns a `ConnectInstance` once you initialize it with a publishable key and a client secret returned from the [Account Session API](https://stripe.com/docs/api/account_sessions/create) call.
+
+```js
+import { loadConnect } from "@stripe/connect-js";
+
+const stripeConnect = await loadConnect();
+const connectInstance = stripeConnect.initialize({
+  publishableKey: "{{pk test123}}",
+  clientSecret: "{{client secret}}"
+});
+```
+
+We’ve placed a random API key in this example. Replace it with your
+[actual publishable API keys](https://dashboard.stripe.com/account/apikeys) to
+test this code through your Connect account.
+
+If you have deployed a
+[Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/Security/CSP),
+make sure to
+[include Connect.js in your directives](https://stripe.com/docs/security/guide#content-security-policy).
+
+### Import as a side effect
+
+Import `@stripe/connect-js` as a side effect in code that will be included
+throughout your site (e.g. your root module). This will make sure the Connect.js
+script tag is inserted immediately upon page load.
+
+```js
+import "@stripe/connect-js";
+```
+
+### Manually include the script tag
+
+Manually add the Connect.js script tag to the `<head>` of each page on your site.
+If an existing script tag is already present, this module will not insert a new
+one. When you call `loadConnect`, it will use the existing script tag.
+
+```html
+<!-- Somewhere in your site's <head> -->
+<script src="https://connect-js.stripe.com/v0.1/connect.js" async></script>
+```
+
+### Importing `loadConnect` without side effects
+
+If you would like to use `loadConnect` in your application, but defer loading the
+Connect.js script until `loadConnect` is first called, use the alternative
+`@stripe/connect-js/pure` import path:
+
+```js
+import { loadConnect } from "@stripe/connect-js/pure";
+
+// Connect.js will not be loaded until `loadConnect` is called
+const stripeConnect = await loadConnect();
+```

package/dist/connect.esm.js

@@ -0,0 +1,91 @@
+const EXISTING_SCRIPT_MESSAGE = "loadConnect was called but an existing Connect.js script already exists in the document; existing script parameters will be used";
+const V0_URL = "https://connect-js.stripe.com/v0.1/connect.js";
+const findScript = () => {
+  return document.querySelectorAll(`script[src="${V0_URL}"]`)[0];
+};
+const injectScript = () => {
+  const script = document.createElement("script");
+  script.src = "https://connect-js.stripe.com/v0.1/connect.js";
+  const head = document.head;
+  if (!head) {
+    throw new Error("Expected document.head not to be null. Connect.js requires a <head> element.");
+  }
+  document.head.appendChild(script);
+  return script;
+};
+let stripePromise = null;
+const loadScript = () => {
+  // Ensure that we only attempt to load Connect.js at most once
+  if (stripePromise !== null) {
+    return stripePromise;
+  }
+  stripePromise = new Promise((resolve, reject) => {
+    if (window.StripeConnect) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+    if (window.StripeConnect) {
+      const wrapper = createWrapper(window.StripeConnect);
+      resolve(wrapper);
+      return;
+    }
+    try {
+      let script = findScript();
+      if (script) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript();
+      }
+      script.addEventListener("load", () => {
+        if (window.StripeConnect) {
+          const wrapper = createWrapper(window.StripeConnect);
+          resolve(wrapper);
+        } else {
+          reject(new Error("Connect.js did not load the necessary objects"));
+        }
+      });
+      script.addEventListener("error", () => {
+        reject(new Error("Failed to load Connect.js"));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  return stripePromise;
+};
+const initStripeConnect = stripeConnectPromise => {
+  if (stripeConnectPromise === null) {
+    return null;
+  }
+  return stripeConnectPromise;
+};
+const createWrapper = stripeConnect => {
+  const wrapper = {
+    initialize: params => {
+      const metaOptions = params.metaOptions ?? {};
+      return stripeConnect.init({
+        ...params,
+        metaOptions: {
+          ...metaOptions,
+          sdk: true
+        }
+      });
+    }
+  };
+  return wrapper;
+};
+
+// Execute our own script injection after a tick to give users time to do their
+// own script injection.
+const stripePromise$1 = Promise.resolve().then(() => loadScript());
+let loadCalled = false;
+stripePromise$1.catch(err => {
+  if (!loadCalled) {
+    console.warn(err);
+  }
+});
+const loadConnect = () => {
+  loadCalled = true;
+  return stripePromise$1.then(maybeConnect => initStripeConnect(maybeConnect));
+};
+
+export { loadConnect };

package/dist/connect.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const EXISTING_SCRIPT_MESSAGE = "loadConnect was called but an existing Connect.js script already exists in the document; existing script parameters will be used";
+const V0_URL = "https://connect-js.stripe.com/v0.1/connect.js";
+const findScript = () => {
+  return document.querySelectorAll(`script[src="${V0_URL}"]`)[0];
+};
+const injectScript = () => {
+  const script = document.createElement("script");
+  script.src = "https://connect-js.stripe.com/v0.1/connect.js";
+  const head = document.head;
+  if (!head) {
+    throw new Error("Expected document.head not to be null. Connect.js requires a <head> element.");
+  }
+  document.head.appendChild(script);
+  return script;
+};
+let stripePromise = null;
+const loadScript = () => {
+  // Ensure that we only attempt to load Connect.js at most once
+  if (stripePromise !== null) {
+    return stripePromise;
+  }
+  stripePromise = new Promise((resolve, reject) => {
+    if (window.StripeConnect) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+    if (window.StripeConnect) {
+      const wrapper = createWrapper(window.StripeConnect);
+      resolve(wrapper);
+      return;
+    }
+    try {
+      let script = findScript();
+      if (script) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript();
+      }
+      script.addEventListener("load", () => {
+        if (window.StripeConnect) {
+          const wrapper = createWrapper(window.StripeConnect);
+          resolve(wrapper);
+        } else {
+          reject(new Error("Connect.js did not load the necessary objects"));
+        }
+      });
+      script.addEventListener("error", () => {
+        reject(new Error("Failed to load Connect.js"));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  return stripePromise;
+};
+const initStripeConnect = stripeConnectPromise => {
+  if (stripeConnectPromise === null) {
+    return null;
+  }
+  return stripeConnectPromise;
+};
+const createWrapper = stripeConnect => {
+  const wrapper = {
+    initialize: params => {
+      const metaOptions = params.metaOptions ?? {};
+      return stripeConnect.init({
+        ...params,
+        metaOptions: {
+          ...metaOptions,
+          sdk: true
+        }
+      });
+    }
+  };
+  return wrapper;
+};
+
+// Execute our own script injection after a tick to give users time to do their
+// own script injection.
+const stripePromise$1 = Promise.resolve().then(() => loadScript());
+let loadCalled = false;
+stripePromise$1.catch(err => {
+  if (!loadCalled) {
+    console.warn(err);
+  }
+});
+const loadConnect = () => {
+  loadCalled = true;
+  return stripePromise$1.then(maybeConnect => initStripeConnect(maybeConnect));
+};
+
+exports.loadConnect = loadConnect;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { LoadConnect } from "./shared";
+export declare const loadConnect: LoadConnect;
+export {};

package/dist/pure.d.ts

@@ -0,0 +1,2 @@
+import { LoadConnect } from "./shared";
+export declare const loadConnect: LoadConnect;

package/dist/pure.esm.js

@@ -0,0 +1,81 @@
+const EXISTING_SCRIPT_MESSAGE = "loadConnect was called but an existing Connect.js script already exists in the document; existing script parameters will be used";
+const V0_URL = "https://connect-js.stripe.com/v0.1/connect.js";
+const findScript = () => {
+  return document.querySelectorAll(`script[src="${V0_URL}"]`)[0];
+};
+const injectScript = () => {
+  const script = document.createElement("script");
+  script.src = "https://connect-js.stripe.com/v0.1/connect.js";
+  const head = document.head;
+  if (!head) {
+    throw new Error("Expected document.head not to be null. Connect.js requires a <head> element.");
+  }
+  document.head.appendChild(script);
+  return script;
+};
+let stripePromise = null;
+const loadScript = () => {
+  // Ensure that we only attempt to load Connect.js at most once
+  if (stripePromise !== null) {
+    return stripePromise;
+  }
+  stripePromise = new Promise((resolve, reject) => {
+    if (window.StripeConnect) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+    if (window.StripeConnect) {
+      const wrapper = createWrapper(window.StripeConnect);
+      resolve(wrapper);
+      return;
+    }
+    try {
+      let script = findScript();
+      if (script) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript();
+      }
+      script.addEventListener("load", () => {
+        if (window.StripeConnect) {
+          const wrapper = createWrapper(window.StripeConnect);
+          resolve(wrapper);
+        } else {
+          reject(new Error("Connect.js did not load the necessary objects"));
+        }
+      });
+      script.addEventListener("error", () => {
+        reject(new Error("Failed to load Connect.js"));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  return stripePromise;
+};
+const initStripeConnect = stripeConnectPromise => {
+  if (stripeConnectPromise === null) {
+    return null;
+  }
+  return stripeConnectPromise;
+};
+const createWrapper = stripeConnect => {
+  const wrapper = {
+    initialize: params => {
+      const metaOptions = params.metaOptions ?? {};
+      return stripeConnect.init({
+        ...params,
+        metaOptions: {
+          ...metaOptions,
+          sdk: true
+        }
+      });
+    }
+  };
+  return wrapper;
+};
+
+const loadConnect = () => {
+  return loadScript().then(maybeStripe => initStripeConnect(maybeStripe));
+};
+
+export { loadConnect };

package/dist/pure.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const EXISTING_SCRIPT_MESSAGE = "loadConnect was called but an existing Connect.js script already exists in the document; existing script parameters will be used";
+const V0_URL = "https://connect-js.stripe.com/v0.1/connect.js";
+const findScript = () => {
+  return document.querySelectorAll(`script[src="${V0_URL}"]`)[0];
+};
+const injectScript = () => {
+  const script = document.createElement("script");
+  script.src = "https://connect-js.stripe.com/v0.1/connect.js";
+  const head = document.head;
+  if (!head) {
+    throw new Error("Expected document.head not to be null. Connect.js requires a <head> element.");
+  }
+  document.head.appendChild(script);
+  return script;
+};
+let stripePromise = null;
+const loadScript = () => {
+  // Ensure that we only attempt to load Connect.js at most once
+  if (stripePromise !== null) {
+    return stripePromise;
+  }
+  stripePromise = new Promise((resolve, reject) => {
+    if (window.StripeConnect) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+    if (window.StripeConnect) {
+      const wrapper = createWrapper(window.StripeConnect);
+      resolve(wrapper);
+      return;
+    }
+    try {
+      let script = findScript();
+      if (script) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript();
+      }
+      script.addEventListener("load", () => {
+        if (window.StripeConnect) {
+          const wrapper = createWrapper(window.StripeConnect);
+          resolve(wrapper);
+        } else {
+          reject(new Error("Connect.js did not load the necessary objects"));
+        }
+      });
+      script.addEventListener("error", () => {
+        reject(new Error("Failed to load Connect.js"));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  return stripePromise;
+};
+const initStripeConnect = stripeConnectPromise => {
+  if (stripeConnectPromise === null) {
+    return null;
+  }
+  return stripeConnectPromise;
+};
+const createWrapper = stripeConnect => {
+  const wrapper = {
+    initialize: params => {
+      const metaOptions = params.metaOptions ?? {};
+      return stripeConnect.init({
+        ...params,
+        metaOptions: {
+          ...metaOptions,
+          sdk: true
+        }
+      });
+    }
+  };
+  return wrapper;
+};
+
+const loadConnect = () => {
+  return loadScript().then(maybeStripe => initStripeConnect(maybeStripe));
+};
+
+exports.loadConnect = loadConnect;

package/dist/shared.d.ts

@@ -0,0 +1,5 @@
+import { StripeConnectWrapper } from "../types";
+export type LoadConnect = () => Promise<StripeConnectWrapper>;
+export declare const findScript: () => HTMLScriptElement | null;
+export declare const loadScript: () => Promise<StripeConnectWrapper | null>;
+export declare const initStripeConnect: (stripeConnectPromise: StripeConnectWrapper | null) => any | null;

package/dist/utils/jestHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const SCRIPT_SELECTOR = "script[src^=\"https://connect-js.stripe.com/v0.1/connect.js\"]";
+export {};

package/dist/utils/jestSetup.d.ts

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

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@stripe/connect-js",
+  "version": "1.0.0",
+  "description": "Connect.js loading utility package",
+  "main": "dist/connect.js",
+  "module": "dist/connect.esm.js",
+  "types": "types/index.d.ts",
+  "typings": "types/index.d.ts",
+  "scripts": {
+    "test": "yarn lint && yarn test:unit --passWithNoTests && yarn typecheck",
+    "test:unit": "jest",
+    "test:types": "zx ./tests/types/scripts/test.mjs",
+    "lint": "eslint '{src,types}/**/*.{ts,js}' && yarn prettier-check",
+    "typecheck": "tsc --noEmit",
+    "build": "yarn clean && rollup -c",
+    "validate-change": "yarn run typescript && yarn run lint && yarn run test",
+    "clean": "rimraf dist",
+    "prettier": "prettier './**/*.{js,ts,md,html,css}' --write",
+    "prettier-check": "prettier './**/*.{js,ts,md,html,css}' --check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stripe/connect-js.git"
+  },
+  "keywords": [
+    "Stripe",
+    "connect.js"
+  ],
+  "author": "Stripe (https://www.stripe.com)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/stripe/connect-js/issues"
+  },
+  "files": [
+    "dist",
+    "src",
+    "types",
+    "pure.js",
+    "pure.d.ts"
+  ],
+  "homepage": "https://github.com/stripe/connect-js#readme",
+  "devDependencies": {
+    "@babel/core": "^7.7.2",
+    "@babel/preset-env": "^7.7.1",
+    "@rollup/plugin-replace": "^2.3.1",
+    "@types/jest": "^24.0.25",
+    "@typescript-eslint/eslint-plugin": "^4.15.2",
+    "@typescript-eslint/parser": "^4.15.2",
+    "babel-eslint": "^10.0.3",
+    "babel-jest": "^24.9.0",
+    "conditional-type-checks": "^1.0.5",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.8.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-jest": "^22.6.3",
+    "eslint-plugin-prettier": "^3.1.1",
+    "jest": "^29.5.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "prettier": "^1.19.1",
+    "rimraf": "^2.6.2",
+    "rollup": "^1.29.0",
+    "rollup-plugin-babel": "^4.4.0",
+    "rollup-plugin-typescript2": "^0.25.3",
+    "ts-jest": "^29.1.0",
+    "typescript": "^4.1.2",
+    "yalc": "^1.0.0-pre.53",
+    "zx": "^4.2.0"
+  }
+}

package/pure.js

@@ -0,0 +1 @@
+module.exports = require("./dist/pure.js");

package/src/index.test.ts

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { SCRIPT_SELECTOR } from "./utils/jestHelpers";
+
+describe("Stripe module loader", () => {
+  jest.spyOn(global, "setTimeout");
+  it("injects the Connect.js script as a side effect after a tick", () => {
+    require("./index");
+
+    expect(document.querySelector(SCRIPT_SELECTOR)).toBe(null);
+    return Promise.resolve().then(() => {
+      expect(document.querySelector(SCRIPT_SELECTOR)).not.toBe(null);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,21 @@
+import { loadScript, initStripeConnect, LoadConnect } from "./shared";
+
+// Execute our own script injection after a tick to give users time to do their
+// own script injection.
+const stripePromise = Promise.resolve().then(() => loadScript());
+
+let loadCalled = false;
+
+stripePromise.catch((err: Error) => {
+  if (!loadCalled) {
+    console.warn(err);
+  }
+});
+
+export const loadConnect: LoadConnect = () => {
+  loadCalled = true;
+
+  return stripePromise.then(maybeConnect => initStripeConnect(maybeConnect));
+};
+
+export {};

package/src/pure.test.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+import { SCRIPT_SELECTOR } from "./utils/jestHelpers";
+
+describe("pure module", () => {
+  test("does not inject the script if loadConnect is not called", async () => {
+    require("./pure");
+
+    expect(document.querySelector(SCRIPT_SELECTOR)).toBe(null);
+  });
+
+  test("it injects the script if loadConnect is called", async () => {
+    const { loadConnect } = require("./pure");
+    loadConnect();
+
+    expect(document.querySelector(SCRIPT_SELECTOR)).not.toBe(null);
+  });
+});

package/src/pure.ts

@@ -0,0 +1,5 @@
+import { loadScript, initStripeConnect, LoadConnect } from "./shared";
+
+export const loadConnect: LoadConnect = () => {
+  return loadScript().then(maybeStripe => initStripeConnect(maybeStripe));
+};

package/src/shared.ts

@@ -0,0 +1,104 @@
+import { StripeConnectWrapper, IStripeConnectInitParams } from "../types";
+
+export type LoadConnect = () => Promise<StripeConnectWrapper>;
+
+const EXISTING_SCRIPT_MESSAGE =
+  "loadConnect was called but an existing Connect.js script already exists in the document; existing script parameters will be used";
+const V0_URL = "https://connect-js.stripe.com/v0.1/connect.js";
+
+export const findScript = (): HTMLScriptElement | null => {
+  return document.querySelectorAll<HTMLScriptElement>(
+    `script[src="${V0_URL}"]`
+  )[0];
+};
+
+const injectScript = (): HTMLScriptElement => {
+  const script = document.createElement("script");
+  script.src = "https://connect-js.stripe.com/v0.1/connect.js";
+
+  const head = document.head;
+
+  if (!head) {
+    throw new Error(
+      "Expected document.head not to be null. Connect.js requires a <head> element."
+    );
+  }
+
+  document.head.appendChild(script);
+
+  return script;
+};
+
+let stripePromise: Promise<StripeConnectWrapper> | null = null;
+
+export const loadScript = (): Promise<StripeConnectWrapper | null> => {
+  // Ensure that we only attempt to load Connect.js at most once
+  if (stripePromise !== null) {
+    return stripePromise;
+  }
+
+  stripePromise = new Promise((resolve, reject) => {
+    if ((window as any).StripeConnect) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+
+    if ((window as any).StripeConnect) {
+      const wrapper = createWrapper((window as any).StripeConnect);
+      resolve(wrapper);
+      return;
+    }
+
+    try {
+      let script = findScript();
+
+      if (script) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript();
+      }
+
+      script.addEventListener("load", () => {
+        if ((window as any).StripeConnect) {
+          const wrapper = createWrapper((window as any).StripeConnect);
+          resolve(wrapper);
+        } else {
+          reject(new Error("Connect.js did not load the necessary objects"));
+        }
+      });
+
+      script.addEventListener("error", () => {
+        reject(new Error("Failed to load Connect.js"));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+
+  return stripePromise;
+};
+
+export const initStripeConnect = (
+  stripeConnectPromise: StripeConnectWrapper | null
+): any | null => {
+  if (stripeConnectPromise === null) {
+    return null;
+  }
+
+  return stripeConnectPromise;
+};
+
+const createWrapper = (stripeConnect: any) => {
+  const wrapper: StripeConnectWrapper = {
+    initialize: (params: IStripeConnectInitParams) => {
+      const metaOptions = (params as any).metaOptions ?? {};
+      return stripeConnect.init({
+        ...params,
+        metaOptions: {
+          ...metaOptions,
+          sdk: true
+        }
+      });
+    }
+  };
+  return wrapper;
+};

package/src/utils/jestHelpers.ts

@@ -0,0 +1,4 @@
+export const SCRIPT_SELECTOR =
+  'script[src^="https://connect-js.stripe.com/v0.1/connect.js"]';
+
+export {};

package/src/utils/jestSetup.ts

@@ -0,0 +1,17 @@
+import { SCRIPT_SELECTOR } from "./jestHelpers";
+
+global.beforeEach(() => {
+  jest.spyOn(console, "warn").mockReturnValue();
+  jest.useFakeTimers();
+});
+
+global.afterEach(() => {
+  const script = document.querySelector(SCRIPT_SELECTOR);
+  if (script && script.parentElement) {
+    script.parentElement.removeChild(script);
+  }
+  jest.resetModules();
+  jest.restoreAllMocks();
+  jest.runOnlyPendingTimers();
+  jest.useRealTimers();
+});

package/types/.eslintrc.yml

@@ -0,0 +1,3 @@
+rules:
+  "@typescript-eslint/triple-slash-reference": 0
+  "@typescript-eslint/adjacent-overload-signatures": 0

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import { LoadConnect } from "../src/shared";
+
+export declare const loadConnect: LoadConnect;
+export * from "./shared";

package/types/shared.d.ts

@@ -0,0 +1,51 @@
+export declare type LoadConnect = () => Promise<StripeConnectWrapper>;
+
+export declare type OverlayOption = "dialog" | "drawer";
+
+export declare type UIConfigOptions = {
+  overlay?: OverlayOption;
+  overlayZIndex?: number;
+};
+
+export declare type AppearanceOptions = {
+  colorPrimary?: string;
+  fontFamily?: string;
+};
+
+export type IStripeConnectUpdateParams = {
+  appearance?: AppearanceOptions;
+};
+
+export interface IStripeConnectInitParams {
+  publishableKey: string;
+  clientSecret: string;
+  appearance?: AppearanceOptions;
+  uiConfig?: UIConfigOptions;
+  refreshClientSecret?: () => Promise<string>;
+}
+
+export interface StripeConnectWrapper {
+  initialize: (params: IStripeConnectInitParams) => StripeConnectInstance;
+}
+
+export interface StripeConnectInstance {
+  create: (tagName: ConnectElementTagName) => HTMLElement | null;
+  update: (options: IStripeConnectUpdateParams) => void;
+}
+
+export type ConnectElementTagName =
+  | "stripe-connect-payments"
+  | "stripe-connect-payouts"
+  | "stripe-connect-account-onboarding"
+  | "stripe-connect-account-management"
+  | "stripe-connect-instant-payouts"
+  | "stripe-connect-payment-details"
+  | "stripe-connect-notification-banner";
+
+export declare const findScript: () => HTMLScriptElement | null;
+
+export declare const loadScript: () => Promise<any | null>;
+
+export declare const initStripeConnect: (
+  stripeConnectPromise: StripeConnectWrapper | null
+) => any | null;