@worldcoin/idkit 0.5.1 → 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2022 Worldcoin Foundation
+
+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/build/chunk-EXZRURG3.js

@@ -0,0 +1,246 @@
+// src/lang/index.ts
+var translations = {};
+var getLang = () => {
+  if (typeof navigator === "undefined" || !navigator.languages)
+    return;
+  const supportedLang = navigator.languages.find((l) => translations[l] != void 0) ?? "";
+  return translations[supportedLang];
+};
+var replaceParams = (str, params) => {
+  let replaced = str;
+  for (const [key, value] of Object.entries(params ?? {}))
+    replaced = str.replace(`:${key}`, value);
+  return replaced;
+};
+function __(str, params) {
+  if (typeof navigator === "undefined")
+    return str;
+  return replaceParams(getLang()?.[str] ?? str, params);
+}
+
+// src/store/idkit.ts
+import { shallow } from "zustand/shallow";
+import { createWithEqualityFn } from "zustand/traditional";
+import {
+  AppErrorCodes,
+  CredentialType
+} from "@worldcoin/idkit-core";
+var useIDKitStore = createWithEqualityFn()(
+  (set, get) => ({
+    app_id: "",
+    signal: "",
+    action: "",
+    action_description: "",
+    bridge_url: "",
+    credential_types: [],
+    open: false,
+    result: null,
+    theme: "light",
+    errorTitle: "",
+    errorDetail: "",
+    autoClose: true,
+    errorState: null,
+    processing: false,
+    errorCallbacks: {},
+    verifyCallbacks: {},
+    successCallbacks: {},
+    stage: "WORLD_ID" /* WORLD_ID */,
+    computed: {
+      canGoBack: (stage) => {
+        return stage == "PRIVACY" /* PRIVACY */;
+      }
+    },
+    setStage: (stage) => set({ stage }),
+    setErrorState: (errorState) => set({ errorState }),
+    setProcessing: (processing) => set({ processing }),
+    retryFlow: () => {
+      set({ stage: "WORLD_ID" /* WORLD_ID */, errorState: null });
+    },
+    addErrorCallback: (cb, source) => {
+      set((state) => {
+        state.errorCallbacks[source] = cb;
+        return state;
+      });
+    },
+    addSuccessCallback: (cb, source) => {
+      set((state) => {
+        state.successCallbacks[source] = cb;
+        return state;
+      });
+    },
+    addVerificationCallback: (cb, source) => {
+      set((state) => {
+        state.verifyCallbacks[source] = cb;
+        return state;
+      });
+    },
+    setOptions: ({
+      handleVerify,
+      onSuccess,
+      signal,
+      action,
+      app_id,
+      onError,
+      credential_types,
+      action_description,
+      bridge_url,
+      autoClose,
+      theme
+    }, source) => {
+      const sanitized_credential_types = credential_types?.filter(
+        (type) => Object.values(CredentialType).includes(type)
+      );
+      set({
+        theme,
+        signal,
+        action,
+        app_id,
+        autoClose,
+        bridge_url,
+        credential_types: sanitized_credential_types,
+        action_description
+      });
+      get().addSuccessCallback(onSuccess, source);
+      if (onError)
+        get().addErrorCallback(onError, source);
+      if (handleVerify)
+        get().addVerificationCallback(handleVerify, source);
+    },
+    handleVerify: (result) => {
+      set({ stage: "HOST_APP_VERIFICATION" /* HOST_APP_VERIFICATION */, processing: false });
+      Promise.all(Object.values(get().verifyCallbacks).map((cb) => cb?.(result))).then(
+        () => {
+          set({ stage: "SUCCESS" /* SUCCESS */, result });
+          if (get().autoClose)
+            setTimeout(() => get().onOpenChange(false), 1e3);
+        },
+        (response) => {
+          let errorMessage = void 0;
+          if (response && typeof response === "object" && response.message) {
+            errorMessage = response.message;
+          }
+          set({
+            stage: "ERROR" /* ERROR */,
+            errorState: {
+              code: AppErrorCodes.FailedByHostApp,
+              message: errorMessage ? __(errorMessage) : void 0
+            }
+          });
+        }
+      );
+    },
+    onOpenChange: (open) => {
+      if (open) {
+        return set({ open });
+      }
+      const errorState = get().errorState;
+      if (get().stage === "ERROR" /* ERROR */ && errorState) {
+        const callbacks = get().errorCallbacks;
+        requestAnimationFrame(() => Object.values(callbacks).forEach((cb) => void cb?.(errorState)));
+      }
+      const result = get().result;
+      if (get().stage == "SUCCESS" /* SUCCESS */ && result) {
+        const callbacks = get().successCallbacks;
+        requestAnimationFrame(() => Object.values(callbacks).forEach((cb) => void cb?.(result)));
+      }
+      set({
+        open,
+        result: null,
+        errorState: null,
+        processing: false,
+        stage: "WORLD_ID" /* WORLD_ID */
+      });
+    }
+  }),
+  shallow
+);
+var idkit_default = useIDKitStore;
+
+// src/types/config.ts
+var ConfigSource = /* @__PURE__ */ ((ConfigSource2) => {
+  ConfigSource2["HOOK"] = "hook";
+  ConfigSource2["PROPS"] = "props";
+  ConfigSource2["MANUAL"] = "manual";
+  return ConfigSource2;
+})(ConfigSource || {});
+
+// src/components/QRCode.tsx
+import { memo, useMemo } from "react";
+import QRCodeUtil from "qrcode/lib/core/qrcode";
+import { jsx } from "react/jsx-runtime";
+var generateMatrix = (data) => {
+  const arr = QRCodeUtil.create(data, { errorCorrectionLevel: "M" }).modules.data;
+  const sqrt = Math.sqrt(arr.length);
+  return arr.reduce((rows, key, index) => {
+    if (index % sqrt === 0)
+      rows.push([key]);
+    else
+      rows[rows.length - 1].push(key);
+    return rows;
+  }, []);
+};
+var Qrcode = ({ data, size = 300 }) => {
+  const dots = useMemo(() => {
+    const dots2 = [];
+    const matrix = generateMatrix(data);
+    const cellSize = size / matrix.length;
+    const qrList = [
+      { x: 0, y: 0 },
+      { x: 1, y: 0 },
+      { x: 0, y: 1 }
+    ];
+    qrList.forEach(({ x, y }) => {
+      const x1 = (matrix.length - 7) * cellSize * x;
+      const y1 = (matrix.length - 7) * cellSize * y;
+      for (let i = 0; i < 3; i++) {
+        dots2.push(
+          /* @__PURE__ */ jsx(
+            "rect",
+            {
+              fill: "currentColor",
+              x: x1 + cellSize * i,
+              y: y1 + cellSize * i,
+              width: cellSize * (7 - i * 2),
+              height: cellSize * (7 - i * 2),
+              rx: (i - 2) * -5,
+              ry: (i - 2) * -5,
+              className: i % 3 === 0 ? "text-black" : i % 3 === 1 ? "text-white" : "text-black"
+            },
+            `${i}-${x}-${y}`
+          )
+        );
+      }
+    });
+    matrix.forEach((row, i) => {
+      row.forEach((_, j) => {
+        if (!matrix[i][j])
+          return;
+        if (i < 7 && j < 7 || i > matrix.length - 8 && j < 7 || i < 7 && j > matrix.length - 8)
+          return;
+        dots2.push(
+          /* @__PURE__ */ jsx(
+            "circle",
+            {
+              fill: "currentColor",
+              r: cellSize / 3,
+              cx: i * cellSize + cellSize / 2,
+              cy: j * cellSize + cellSize / 2,
+              className: "text-black dark:text-white"
+            },
+            `circle-${i}-${j}`
+          )
+        );
+      });
+    });
+    return dots2;
+  }, [size, data]);
+  return /* @__PURE__ */ jsx("svg", { height: size, width: size, children: dots });
+};
+var QRCode_default = memo(Qrcode);
+
+export {
+  __,
+  idkit_default,
+  ConfigSource,
+  QRCode_default
+};

package/build/config-cd2f02fe.d.ts

@@ -0,0 +1,36 @@
+import { IDKitConfig, ISuccessResult, IErrorState } from '@worldcoin/idkit-core';
+
+declare enum IDKITStage {
+    WORLD_ID = "WORLD_ID",
+    PRIVACY = "PRIVACY",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR",
+    HOST_APP_VERIFICATION = "HOST_APP_VERIFICATION"
+}
+type CallbackFn<T> = (result: T) => Promise<void> | void;
+
+declare enum ConfigSource {
+    HOOK = "hook",
+    PROPS = "props",
+    MANUAL = "manual"
+}
+type WidgetConfig = {
+    /** Whether to automatically close the widget after a successful verification. Defaults to `false`. */
+    autoClose?: boolean;
+    /** The theme to apply to the widget's UI. Defaults to `light`. */
+    theme?: 'dark' | 'light';
+    /** Function to trigger when verification is successful. Should receive a single parameter of type `ISuccessResult` which contains the proof details. */
+    onSuccess: CallbackFn<ISuccessResult>;
+    /** Called after the proof is returned from the World App, but before showing the success screen. Throwing in this screen will show the user a custom error. Used to perform additional validation when needed. */
+    handleVerify?: CallbackFn<ISuccessResult>;
+    /** Function to trigger when verification is not successful. Should receive a single parameter of type `IErrorState` which contains the error details. */
+    onError?: CallbackFn<IErrorState>;
+};
+type Config = IDKitConfig & Required<Pick<IDKitConfig, 'action'>> & WidgetConfig;
+type WidgetProps = Config & {
+    children?: ({ open }: {
+        open: () => void;
+    }) => JSX.Element;
+};
+
+export { Config as C, IDKITStage as I, WidgetProps as W, WidgetConfig as a, ConfigSource as b, CallbackFn as c };

package/build/index.d.ts

@@ -0,0 +1,31 @@
+import { C as Config, W as WidgetProps, a as WidgetConfig } from './config-cd2f02fe.js';
+import { MotionProps } from 'framer-motion';
+import * as react from 'react';
+import { FC, ButtonHTMLAttributes } from 'react';
+import { IDKitConfig } from '@worldcoin/idkit-core';
+export { CredentialType, ISuccessResult } from '@worldcoin/idkit-core';
+export { solidityEncode } from '@worldcoin/idkit-core/hashing';
+
+type HookConfig = Partial<Pick<Config, 'handleVerify' | 'onSuccess'>>;
+declare const useIDKit: ({ handleVerify, onSuccess }?: HookConfig) => {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+type Props$1 = ButtonHTMLAttributes<HTMLButtonElement> & MotionProps & {
+    theme?: 'dark' | 'light';
+};
+declare const SignInButton: FC<Props$1>;
+
+declare const _default: react.NamedExoticComponent<WidgetProps>;
+
+type Props = Omit<WidgetConfig, 'autoClose' | 'handleVerify'> & Pick<IDKitConfig, 'app_id'> & {
+    nonce?: string;
+    onSuccess: (jwt: string) => void;
+    children?: ({ open }: {
+        open: () => void;
+    }) => JSX.Element;
+};
+declare const SignInWithWorldID: FC<Props>;
+
+export { Config, _default as IDKitWidget, SignInButton, SignInWithWorldID, WidgetProps, useIDKit };