@lacagnottedesproches/lcdp-js-lite 1.6.0

package/src/index.ts

@@ -0,0 +1,151 @@
+// @see https://github.com/stripe/stripe-js
+import { LCDPRequest } from "./api";
+import { LCDP, LCDPConstructor, LoadLCDP } from "./types";
+export * from "./types";
+
+let lcdpPromise: Promise<LCDPConstructor | null> | null = null;
+let loadCalled: boolean = false;
+
+const API_URL = "https://api.lacagnottedesproches.fr";
+const API_URL_REGEX = (url: string) => new RegExp(`/^${url}?(.*)$/`);
+let onErrorListener: (() => void) | null = null;
+let onLoadListener: (() => void) | null = null;
+
+const onError = (reject: (reason?: any) => void) => () => {
+  reject(new Error("Failed to load lcdp.js"));
+};
+
+const onLoad =
+  (
+    resolve: (value: LCDPConstructor | null) => void,
+    reject: (reason?: any) => void,
+  ) =>
+  () => {
+    if (window.lcdp?.Afina) {
+      resolve(window.lcdp.Afina);
+    } else {
+      reject(new Error("lcdp.js not available"));
+    }
+  };
+
+const findScript = (
+  url: string,
+  url_regex: RegExp,
+): HTMLScriptElement | null => {
+  const scripts = document.querySelectorAll<HTMLScriptElement>(
+    `script[src^="${url}"]`,
+  );
+  for (let i = 0; i < scripts.length; i++) {
+    const script = scripts[i];
+    if (!url_regex.test(script.src)) {
+      continue;
+    }
+    return script;
+  }
+  return null;
+};
+
+const injectScript = (url: string): HTMLScriptElement => {
+  const script = document.createElement("script");
+  script.src = `${url}/js`;
+  const headOrBody = document.head || document.body;
+  if (!headOrBody) {
+    throw new Error(
+      "Expected document.body not to be null. Stripe.js requires a <body> element.",
+    );
+  }
+  headOrBody.appendChild(script);
+  const divModalRoot = document.createElement("div");
+  divModalRoot.id = "lcdp-modal-root";
+  document.body.appendChild(divModalRoot);
+  return script;
+};
+
+const getLCDPPromise: (
+  args?: Parameters<LCDPConstructor>,
+) => Promise<LCDPConstructor | null> = (args) => {
+  if (lcdpPromise) {
+    return lcdpPromise;
+  }
+  lcdpPromise = new Promise((resolve, reject) => {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      resolve(null);
+      return;
+    }
+
+    if (window.lcdp?.Afina) {
+      resolve(window.lcdp.Afina);
+      return;
+    }
+
+    let url = API_URL;
+    let url_regex = API_URL_REGEX(url);
+
+    if (args && args.length >= 2) {
+      let opts = args[1];
+      if (opts?.api_url) {
+        url = opts.api_url;
+        url_regex = API_URL_REGEX(url);
+      }
+    }
+
+    try {
+      let script: HTMLScriptElement | null = findScript(url, url_regex);
+      if (script) {
+        console.warn("it seems a lcdp script already exists.");
+      } else if (!script) {
+        script = injectScript(url);
+      } else if (
+        script &&
+        onLoadListener !== null &&
+        onErrorListener !== null
+      ) {
+        // remove event listeners
+        (script as HTMLScriptElement).removeEventListener(
+          "load",
+          onLoadListener,
+        );
+        (script as HTMLScriptElement).removeEventListener(
+          "error",
+          onErrorListener,
+        );
+
+        // if script exists, but we are reloading due to an error,
+        // reload script to trigger 'load' event
+        (script as HTMLScriptElement).parentNode?.removeChild(script);
+        script = injectScript(url);
+      }
+
+      onLoadListener = onLoad(resolve, reject);
+      onErrorListener = onError(reject);
+      script.addEventListener("load", onLoadListener);
+
+      script.addEventListener("error", onErrorListener);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+  });
+  return lcdpPromise;
+};
+
+const initLCDP = async (
+  maybeLCDP: LCDPConstructor | null,
+  args: Parameters<LCDPConstructor>,
+): Promise<LCDP | null> => {
+  if (maybeLCDP === null) {
+    return Promise.resolve(null);
+  }
+  const lcdp: LCDP = new (maybeLCDP as any)(...args);
+  return lcdp.init().then((lcdpReady) => lcdpReady);
+};
+
+export const loadLCDP: LoadLCDP = async (...args) => {
+  loadCalled = true;
+  return getLCDPPromise(args).then((lcdp) => {
+    return initLCDP(lcdp, args);
+  });
+};
+
+export const requestLCDP = (secret: string, apiUrl: string = API_URL) =>
+  new LCDPRequest(secret, apiUrl);

package/src/types.ts

@@ -0,0 +1,320 @@
+import { Stripe } from "@stripe/stripe-js";
+import { UUID } from "crypto";
+
+export enum AfinaError {
+  Verify = "Fail to verify origin request",
+  Stripe = "Stripe is not available",
+  ClientSide = "Should be on Client Side",
+  Key = "A publishable key is mandatory",
+}
+
+export enum TokenObjectType {
+  Account = "account",
+  Pot = "pot",
+  Wizard = "wizard",
+}
+
+export interface Country {
+  id: string;
+  name: string;
+}
+
+export interface Category {
+  id: string;
+  name: string;
+  slug: string;
+  icon: string | null;
+  icon_url: string | null;
+}
+
+export interface TokenObject {
+  id: string;
+  type: TokenObjectType;
+  client_ip: string;
+}
+
+interface Pagination {
+  has_next: boolean;
+  has_prev: boolean;
+  page: number;
+  pages: number;
+  per_page: number;
+  total: number;
+}
+
+export interface ProfitAccount {
+  entity_name: string | null;
+  entity_url: string | null;
+}
+
+export interface Pot {
+  id: string;
+  date_created_ts: number;
+  slug: string;
+  name: string;
+  date_end_ts: number | null;
+  objectif: number | null;
+  status_online: boolean;
+  status_public: boolean;
+  status_closed: boolean;
+  amount_collected_hidden: boolean;
+  public_pot_url: string;
+  public_donation_url: string;
+  stat_amount_donation: number | null;
+  stat_nb_donation: number;
+  profit_acct: ProfitAccount | null;
+  profit_ghost: ProfitAccount | null;
+  description: string | null;
+  video: string | null;
+  visual_main_url: string | null;
+  visual_secondary_url: string | null;
+  with_tax_receipt: boolean;
+}
+
+export interface PotsPagination extends Pagination {
+  items: Pot[];
+}
+
+export interface PayloadAccount {
+  email: string;
+  password?: string | null;
+  first_name: string;
+  last_name: string;
+  birth_date: Date;
+  address: string;
+  postcode: string;
+  city: string;
+  phone_number: string;
+  country_code: string;
+  tags?: string[] | undefined;
+}
+
+interface PayloadPotBase {
+  name: string;
+  category_id: string;
+  amount_target?: number | undefined;
+  ts_end?: number | undefined;
+  status_public?: boolean | undefined;
+  total_amount_hidden?: boolean | undefined;
+  description?: string | undefined;
+  assoid?: string | undefined;
+}
+
+export interface PayloadPot extends PayloadPotBase {
+  acct_id: string;
+}
+
+export interface PayloadPotUpdate {
+  pot_id: UUID;
+  name?: string | undefined;
+  category_id?: UUID | undefined;
+  objectif?: number | undefined;
+  date_end_ts?: number | undefined;
+  status_public?: boolean | undefined;
+  amount_collected_hidden?: boolean | undefined;
+  description?: string | undefined;
+}
+
+export interface PayloadAccountAndPot extends PayloadAccount, PayloadPotBase {}
+
+export interface DataDonation {
+  first_name: string;
+  last_name: string;
+  email: string;
+  pot_id: UUID;
+  return_url: string;
+  message?: string | null | undefined;
+  stay_anonymous?: boolean | null | undefined;
+  hide_amount_donation?: boolean | null | undefined;
+  is_newsletter?: boolean | null | undefined;
+  address?: string | null | undefined;
+  postcode?: string | null | undefined;
+  city?: string | null | undefined;
+  country?: string | null | undefined;
+  org_name?: string | null | undefined;
+  org_siren?: string | null | undefined;
+  org_status?: string | null | undefined;
+}
+
+export interface PayloadDonation extends DataDonation {
+  confirmation_token_id: string;
+  idempotency_key: string;
+  amount_donation: number;
+  amount_tip: number;
+}
+
+export interface DonationResult {
+  error?: string;
+  status: string | "requires_action";
+  client_secret: string;
+  donation_id?: UUID;
+}
+
+export interface AccountCreated {
+  acct_id: string;
+  first_name: string;
+  last_name: string;
+  email: string;
+}
+
+export interface PotCreated {
+  pot_id: string;
+  name: string;
+  slug: string;
+}
+
+export interface AccountAndPotCreated {
+  account: AccountCreated;
+  pot: PotCreated;
+}
+
+export interface StatMetric {
+  nb_pots: number;
+  amount_donations: number;
+  amount_moy_donations: number;
+  nb_donations: number;
+}
+
+export interface StatMetricTips {
+  nb_tips: number;
+  amount: number;
+  amount_real: number;
+}
+
+export interface StatDashboard {
+  total: StatMetric;
+  date_range: StatMetric;
+  tips?: {
+    total: StatMetricTips;
+    date_range: StatMetricTips;
+  };
+}
+
+export interface StatsPot {
+  id: string;
+  date_created_ts: number;
+  slug: string;
+  name: string;
+  status_online: boolean;
+  status_public: boolean;
+  status_closed: boolean;
+  owner_first_name: string | null;
+  owner_last_name: string | null;
+  tags?: string | null;
+  nb_donations: number;
+  amount_donations: number | null;
+  amount_moy_donations: number | null;
+  nb_tips?: number;
+  amount_tips?: number;
+  amount_real_tips?: number;
+}
+
+export interface StatsPotsPagination extends Pagination {
+  items: StatsPot[];
+}
+
+export interface Association {
+  id: string;
+  nom: string;
+  recu_fiscal: 0 | 1;
+  mise_en_avant: 0 | 1;
+  categories?: string[];
+  description_courte?: string;
+  link_logo: string;
+  alt_logo: string;
+  link_cta_pot: string;
+  lien_page_wordpress: string;
+  assoid: string;
+}
+
+export interface Associations {
+  hits: Association[];
+  offset: number;
+  limit: number;
+  query: string;
+}
+
+export interface PayloadQueryAssociations {
+  q?: string;
+  limit?: number;
+  offset?: number;
+  filter?: string[][];
+}
+
+export interface AssociationCategory {
+  id: string;
+  name: string;
+  picto?: string;
+}
+
+/**
+ * Represents available features from Afina API.
+ */
+export interface LCDP {
+  stripe: Stripe | undefined | null;
+  init: () => Promise<LCDP>;
+  createTokenAccount: (payload: PayloadAccount) => Promise<TokenObject>;
+  createTokenPot: (payload: PayloadPot) => Promise<TokenObject>;
+  createTokenAccountAndPot: (
+    payload: PayloadAccountAndPot,
+  ) => Promise<TokenObject>;
+  createTokenPotUpdate: (payload: PayloadPotUpdate) => Promise<TokenObject>;
+  createDonation: (payload: PayloadDonation) => Promise<DonationResult>;
+  getAvailableCountries: () => Promise<Country[]>;
+  getCategories: () => Promise<Category[]>;
+  getPots: (params?: ParamsPagination) => Promise<PotsPagination>;
+  getPot: (potId: string) => Promise<Pot>;
+  getStatsDashboard: (
+    ts_start?: number,
+    ts_end?: number,
+  ) => Promise<StatDashboard>;
+  getStatsPots: (
+    ts_start?: number,
+    ts_end?: number,
+    page?: number,
+    per_page?: number,
+  ) => Promise<StatsPotsPagination>;
+  retrieveAssociations: (
+    payload?: PayloadQueryAssociations,
+  ) => Promise<Associations>;
+  getAssociation: (id: string) => Promise<Association>;
+  getAssociationCategories: () => Promise<AssociationCategory[]>;
+}
+
+export interface LCDPApi {
+  createAccount: (payload: TokenObject) => Promise<AccountCreated>;
+  createPot: (payload: TokenObject) => Promise<PotCreated>;
+  createAccountAndPot: (payload: TokenObject) => Promise<AccountAndPotCreated>;
+  updatePot: (payload: TokenObject) => Promise<void>;
+}
+
+export type LCDPOpts = {
+  api_url?: string;
+};
+
+export interface LCDPConstructor {
+  (lcdpPubKey: string, options?: LCDPOpts): LCDP;
+}
+
+export type LoadLCDP = (
+  ...args: Parameters<LCDPConstructor>
+) => Promise<LCDP | null>;
+
+export interface ParamsPagination {
+  page?: number;
+  per_page?: number;
+}
+
+declare global {
+  interface Window {
+    lcdp?: {
+      Afina: LCDPConstructor;
+    };
+  }
+}
+
+export interface DataAccount extends Omit<PayloadAccount, "birth_date"> {
+  birth_date: number;
+}
+
+export {};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "target": "ESNext",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "moduleResolution": "node"
+  },
+  "include": ["./src/**/*"]
+}