@cedarjs/auth-dbauth-web 0.5.1-next.0 → 0.6.0

package/dist/cjs/dbAuth.d.ts

@@ -0,0 +1,42 @@
+import type { CurrentUser } from '@cedarjs/auth';
+import type { WebAuthnClientType } from './webAuthn.js';
+export interface LoginAttributes {
+    username: string;
+    password: string;
+}
+export interface ResetPasswordAttributes {
+    resetToken: string;
+    password: string;
+}
+export type SignupAttributes = Record<string, unknown> & LoginAttributes;
+export declare function createAuth(dbAuthClient: ReturnType<typeof createDbAuthClient>, customProviderHooks?: {
+    useCurrentUser?: () => Promise<CurrentUser>;
+    useHasRole?: (currentUser: CurrentUser | null) => (rolesToCheck: string | string[]) => boolean;
+}): {
+    AuthContext: import("react").Context<import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default> | undefined>;
+    AuthProvider: ({ children }: import("@cedarjs/auth").AuthProviderProps) => import("react").JSX.Element;
+    useAuth: () => import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default>;
+};
+export interface DbAuthClientArgs {
+    webAuthn?: InstanceType<WebAuthnClientType>;
+    dbAuthUrl?: string;
+    fetchConfig?: {
+        credentials?: 'include' | 'same-origin';
+    };
+    middleware?: boolean;
+}
+export declare function createDbAuthClient({ webAuthn, dbAuthUrl, fetchConfig, middleware, }?: DbAuthClientArgs): {
+    type: string;
+    client: import("./webAuthn.js").default | undefined;
+    login: ({ username, password }: LoginAttributes) => Promise<any>;
+    logout: () => Promise<boolean>;
+    signup: (attributes: SignupAttributes) => Promise<any>;
+    getToken: () => Promise<string | null>;
+    getUserMetadata: () => Promise<string | (() => void) | null>;
+    forgotPassword: (username: string) => Promise<any>;
+    resetPassword: (attributes: ResetPasswordAttributes) => Promise<any>;
+    validateResetToken: (resetToken: string | null) => Promise<any>;
+    getAuthUrl: () => string;
+    middlewareAuthEnabled: boolean;
+};
+//# sourceMappingURL=dbAuth.d.ts.map

package/dist/cjs/dbAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbAuth.d.ts","sourceRoot":"","sources":["../../src/dbAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAA;AAMrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAAA;AAkBxE,wBAAgB,UAAU,CACxB,YAAY,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACnD,mBAAmB,CAAC,EAAE;IACpB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3C,UAAU,CAAC,EAAE,CACX,WAAW,EAAE,WAAW,GAAG,IAAI,KAC5B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,OAAO,CAAA;CAClD;;wCAEA,eAAgC,+BACb,OAAO;;EAI5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,YAAY,CAAC,kBAAkB,CAAC,CAAA;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE;QACZ,WAAW,CAAC,EAAE,SAAS,GAAG,aAAa,CAAA;KACxC,CAAA;IACD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAA4C,GAC7C,GAAE,gBAAqB;;;oCA6EuB,eAAe;;yBAgC1B,gBAAgB;;;+BA9EV,MAAM;gCAmEL,uBAAuB;qCAsBlB,MAAM,GAAG,IAAI;;;EAoC5D"}

package/dist/cjs/dbAuth.js

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dbAuth_exports = {};
+__export(dbAuth_exports, {
+  createAuth: () => createAuth,
+  createDbAuthClient: () => createDbAuthClient
+});
+module.exports = __toCommonJS(dbAuth_exports);
+var import_auth = require("@cedarjs/auth");
+const TOKEN_CACHE_TIME = 5e3;
+function createMiddlewareAuth(dbAuthClient, customProviderHooks) {
+  return (0, import_auth.createAuthentication)(dbAuthClient, {
+    ...customProviderHooks,
+    useCurrentUser: customProviderHooks?.useCurrentUser ?? (() => (0, import_auth.getCurrentUserFromMiddleware)(dbAuthClient.getAuthUrl()))
+  });
+}
+function createAuth(dbAuthClient, customProviderHooks) {
+  if (dbAuthClient.middlewareAuthEnabled) {
+    return createMiddlewareAuth(dbAuthClient, customProviderHooks);
+  }
+  return (0, import_auth.createAuthentication)(dbAuthClient, customProviderHooks);
+}
+function createDbAuthClient({
+  webAuthn,
+  dbAuthUrl,
+  fetchConfig,
+  middleware = RWJS_ENV.RWJS_EXP_STREAMING_SSR
+} = {}) {
+  const credentials = fetchConfig?.credentials || "same-origin";
+  webAuthn?.setAuthApiUrl(dbAuthUrl);
+  let getTokenPromise;
+  let lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
+  let cachedToken;
+  const getDbAuthUrl = () => {
+    if (dbAuthUrl) {
+      return dbAuthUrl;
+    }
+    return middleware ? `/middleware/dbauth` : `${RWJS_API_URL}/auth`;
+  };
+  const resetAndFetch = async (...params) => {
+    resetTokenCache();
+    return fetch(...params);
+  };
+  const isTokenCacheExpired = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.getTime() - lastTokenCheckAt.getTime() > TOKEN_CACHE_TIME;
+  };
+  const resetTokenCache = () => {
+    lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
+    cachedToken = null;
+  };
+  const forgotPassword = async (username) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, method: "forgotPassword" })
+    });
+    return response.json();
+  };
+  const getToken = async () => {
+    if (middleware) {
+      return null;
+    }
+    if (getTokenPromise) {
+      return getTokenPromise;
+    }
+    if (isTokenCacheExpired()) {
+      getTokenPromise = fetch(`${getDbAuthUrl()}?method=getToken`, {
+        credentials
+      }).then((response) => response.text()).then((tokenText) => {
+        lastTokenCheckAt = /* @__PURE__ */ new Date();
+        cachedToken = tokenText.length === 0 ? null : tokenText;
+        return cachedToken;
+      }).catch(() => {
+        return null;
+      }).finally(() => {
+        getTokenPromise = null;
+      });
+      return getTokenPromise;
+    }
+    return cachedToken;
+  };
+  const login = async ({ username, password }) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, password, method: "login" })
+    });
+    return response.json();
+  };
+  const logout = async () => {
+    await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      body: JSON.stringify({ method: "logout" })
+    });
+    return true;
+  };
+  const resetPassword = async (attributes) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "resetPassword" })
+    });
+    return response.json();
+  };
+  const signup = async (attributes) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "signup" })
+    });
+    return response.json();
+  };
+  const validateResetToken = async (resetToken) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ resetToken, method: "validateResetToken" })
+    });
+    return response.json();
+  };
+  const getUserMetadata = async () => {
+    return middleware ? () => {
+    } : getToken();
+  };
+  return {
+    type: "dbAuth",
+    client: webAuthn,
+    login,
+    logout,
+    signup,
+    getToken,
+    getUserMetadata,
+    forgotPassword,
+    resetPassword,
+    validateResetToken,
+    // New methods for middleware auth:
+    // This is so we can get the dbAuthUrl in getCurrentUserFromMiddleware
+    getAuthUrl: getDbAuthUrl,
+    // This is so that we can skip fetching getCurrentUser in reauthenticate
+    middlewareAuthEnabled: middleware
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuth,
+  createDbAuthClient
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dbAuth.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./dbAuth.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./dbAuth.js")
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/webAuthn.d.ts

@@ -0,0 +1,13 @@
+export default class WebAuthnClient {
+    authApiUrl: string;
+    private getAuthApiUrl;
+    setAuthApiUrl(authApiUrl?: string): void;
+    isSupported(): Promise<any>;
+    isEnabled(): boolean;
+    private authenticationOptions;
+    authenticate(): Promise<boolean>;
+    private registrationOptions;
+    register(): Promise<boolean>;
+}
+export type WebAuthnClientType = typeof WebAuthnClient;
+//# sourceMappingURL=webAuthn.d.ts.map

package/dist/cjs/webAuthn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webAuthn.d.ts","sourceRoot":"","sources":["../../src/webAuthn.ts"],"names":[],"mappings":"AAqCA,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,UAAU,SAAK;IAEf,OAAO,CAAC,aAAa;IAIrB,aAAa,CAAC,UAAU,CAAC,EAAE,MAAM;IAM3B,WAAW;IAKjB,SAAS;YAQK,qBAAqB;IAmC7B,YAAY;IA0ClB,OAAO,CAAC,mBAAmB;IA+BrB,QAAQ;CAwCf;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,cAAc,CAAA"}

package/dist/cjs/webAuthn.js

@@ -0,0 +1,210 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webAuthn_exports = {};
+__export(webAuthn_exports, {
+  default: () => WebAuthnClient
+});
+module.exports = __toCommonJS(webAuthn_exports);
+class WebAuthnRegistrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAuthnRegistrationError";
+  }
+}
+class WebAuthnAuthenticationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAuthnAuthenticationError";
+  }
+}
+class WebAuthnAlreadyRegisteredError extends WebAuthnRegistrationError {
+  constructor() {
+    super("This device is already registered");
+    this.name = "WebAuthnAlreadyRegisteredError";
+  }
+}
+class WebAuthnDeviceNotFoundError extends WebAuthnAuthenticationError {
+  constructor() {
+    super("WebAuthn device not found");
+    this.name = "WebAuthnDeviceNotFoundError";
+  }
+}
+class WebAuthnNoAuthenticatorError extends WebAuthnAuthenticationError {
+  constructor() {
+    super(
+      "This device was not recognized. Use username/password login, or if you're using iOS you can try reloading this page"
+    );
+    this.name = "WebAuthnNoAuthenticatorError";
+  }
+}
+class WebAuthnClient {
+  authApiUrl = "";
+  getAuthApiUrl() {
+    return this.authApiUrl || `${RWJS_API_URL}/auth`;
+  }
+  setAuthApiUrl(authApiUrl) {
+    if (authApiUrl) {
+      this.authApiUrl = authApiUrl;
+    }
+  }
+  async isSupported() {
+    const { browserSupportsWebAuthn } = await import("@simplewebauthn/browser");
+    return browserSupportsWebAuthn();
+  }
+  isEnabled() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    return !!/\bwebAuthn\b/.test(document.cookie);
+  }
+  async authenticationOptions() {
+    let options;
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnAuthOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(null);
+      options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        if (options.error?.match(/username and password/)) {
+          throw new WebAuthnDeviceNotFoundError();
+        } else {
+          throw new WebAuthnAuthenticationError(
+            `Could not start authentication: ${options.error}`
+          );
+        }
+      }
+    } catch (e) {
+      console.error(e.message);
+      throw new WebAuthnAuthenticationError(
+        `Could not start authentication: ${e.message}`
+      );
+    }
+    return options;
+  }
+  async authenticate() {
+    const authOptions = await this.authenticationOptions();
+    const { startAuthentication } = await import("@simplewebauthn/browser");
+    try {
+      const browserResponse = await startAuthentication(authOptions);
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(
+        JSON.stringify({
+          method: "webAuthnAuthenticate",
+          ...browserResponse
+        })
+      );
+      const options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnAuthenticationError(
+          `Could not complete authentication: ${options.error}`
+        );
+      }
+    } catch (e) {
+      if (e.message.match(
+        /No available authenticator recognized any of the allowed credentials/
+      )) {
+        throw new WebAuthnNoAuthenticatorError();
+      } else {
+        throw new WebAuthnAuthenticationError(
+          `Error while authenticating: ${e.message}`
+        );
+      }
+    }
+    return true;
+  }
+  registrationOptions() {
+    let options;
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnRegOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(null);
+      options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnRegistrationError(
+          `Could not start registration: ${options.error}`
+        );
+      }
+    } catch (e) {
+      console.error(e);
+      throw new WebAuthnRegistrationError(
+        `Could not start registration: ${e.message}`
+      );
+    }
+    return options;
+  }
+  async register() {
+    const options = await this.registrationOptions();
+    let regResponse;
+    const { startRegistration } = await import("@simplewebauthn/browser");
+    try {
+      regResponse = await startRegistration(options);
+    } catch (e) {
+      if (e.name === "InvalidStateError") {
+        throw new WebAuthnAlreadyRegisteredError();
+      } else {
+        throw new WebAuthnRegistrationError(
+          `Error while registering: ${e.message}`
+        );
+      }
+    }
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(JSON.stringify({ method: "webAuthnRegister", ...regResponse }));
+      const options2 = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnRegistrationError(
+          `Could not complete registration: ${options2.error}`
+        );
+      }
+    } catch (e) {
+      throw new WebAuthnRegistrationError(
+        `Error while registering: ${e.message}`
+      );
+    }
+    return true;
+  }
+}

package/dist/dbAuth.d.ts

@@ -1,5 +1,5 @@
 import type { CurrentUser } from '@cedarjs/auth';
-import type { WebAuthnClientType } from './webAuthn';
+import type { WebAuthnClientType } from './webAuthn.js';
 export interface LoginAttributes {
     username: string;
     password: string;
@@ -13,9 +13,9 @@ export declare function createAuth(dbAuthClient: ReturnType<typeof createDbAuthC
     useCurrentUser?: () => Promise<CurrentUser>;
     useHasRole?: (currentUser: CurrentUser | null) => (rolesToCheck: string | string[]) => boolean;
 }): {
-    AuthContext: import("react").Context<import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn").default> | undefined>;
+    AuthContext: import("react").Context<import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default> | undefined>;
     AuthProvider: ({ children }: import("@cedarjs/auth").AuthProviderProps) => import("react").JSX.Element;
-    useAuth: () => import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn").default>;
+    useAuth: () => import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default>;
 };
 export interface DbAuthClientArgs {
     webAuthn?: InstanceType<WebAuthnClientType>;
@@ -27,7 +27,7 @@ export interface DbAuthClientArgs {
 }
 export declare function createDbAuthClient({ webAuthn, dbAuthUrl, fetchConfig, middleware, }?: DbAuthClientArgs): {
     type: string;
-    client: import("./webAuthn").default | undefined;
+    client: import("./webAuthn.js").default | undefined;
     login: ({ username, password }: LoginAttributes) => Promise<any>;
     logout: () => Promise<boolean>;
     signup: (attributes: SignupAttributes) => Promise<any>;

package/dist/dbAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dbAuth.d.ts","sourceRoot":"","sources":["../src/dbAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAA;AAMrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAAA;AAkBxE,wBAAgB,UAAU,CACxB,YAAY,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACnD,mBAAmB,CAAC,EAAE;IACpB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3C,UAAU,CAAC,EAAE,CACX,WAAW,EAAE,WAAW,GAAG,IAAI,KAC5B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,OAAO,CAAA;CAClD;;wCAEG,eAAgC,+BACb,OAAO;;EAI/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,YAAY,CAAC,kBAAkB,CAAC,CAAA;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE;QACZ,WAAW,CAAC,EAAE,SAAS,GAAG,aAAa,CAAA;KACxC,CAAA;IACD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAA4C,GAC7C,GAAE,gBAAqB;;;oCA6EuB,eAAe;;yBAgC1B,gBAAgB;;;+BA9EV,MAAM;gCAmEL,uBAAuB;qCAsBlB,MAAM,GAAG,IAAI;;;EAoC5D"}
+{"version":3,"file":"dbAuth.d.ts","sourceRoot":"","sources":["../src/dbAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAA;AAMrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAAA;AAkBxE,wBAAgB,UAAU,CACxB,YAAY,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACnD,mBAAmB,CAAC,EAAE;IACpB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3C,UAAU,CAAC,EAAE,CACX,WAAW,EAAE,WAAW,GAAG,IAAI,KAC5B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,OAAO,CAAA;CAClD;;wCAEA,eAAgC,+BACb,OAAO;;EAI5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,YAAY,CAAC,kBAAkB,CAAC,CAAA;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE;QACZ,WAAW,CAAC,EAAE,SAAS,GAAG,aAAa,CAAA;KACxC,CAAA;IACD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAA4C,GAC7C,GAAE,gBAAqB;;;oCA6EuB,eAAe;;yBAgC1B,gBAAgB;;;+BA9EV,MAAM;gCAmEL,uBAAuB;qCAsBlB,MAAM,GAAG,IAAI;;;EAoC5D"}

package/dist/dbAuth.js

@@ -1,29 +1,19 @@
-"use strict";
-
-var _Object$defineProperty = require("@babel/runtime-corejs3/core-js/object/define-property");
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createAuth = createAuth;
-exports.createDbAuthClient = createDbAuthClient;
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js/json/stringify"));
-var _auth = require("@cedarjs/auth");
-const TOKEN_CACHE_TIME = 5000;
-
-// This is the middleware-edition auth function
-// Overrides the default getCurrentUser to fetch it from middleware instead
+import {
+  createAuthentication,
+  getCurrentUserFromMiddleware
+} from "@cedarjs/auth";
+const TOKEN_CACHE_TIME = 5e3;
 function createMiddlewareAuth(dbAuthClient, customProviderHooks) {
-  return (0, _auth.createAuthentication)(dbAuthClient, {
+  return createAuthentication(dbAuthClient, {
     ...customProviderHooks,
-    useCurrentUser: customProviderHooks?.useCurrentUser ?? (() => (0, _auth.getCurrentUserFromMiddleware)(dbAuthClient.getAuthUrl()))
+    useCurrentUser: customProviderHooks?.useCurrentUser ?? (() => getCurrentUserFromMiddleware(dbAuthClient.getAuthUrl()))
   });
 }
 function createAuth(dbAuthClient, customProviderHooks) {
   if (dbAuthClient.middlewareAuthEnabled) {
     return createMiddlewareAuth(dbAuthClient, customProviderHooks);
   }
-  return (0, _auth.createAuthentication)(dbAuthClient, customProviderHooks);
+  return createAuthentication(dbAuthClient, customProviderHooks);
 }
 function createDbAuthClient({
   webAuthn,
@@ -31,10 +21,10 @@ function createDbAuthClient({
   fetchConfig,
   middleware = RWJS_ENV.RWJS_EXP_STREAMING_SSR
 } = {}) {
-  const credentials = fetchConfig?.credentials || 'same-origin';
+  const credentials = fetchConfig?.credentials || "same-origin";
   webAuthn?.setAuthApiUrl(dbAuthUrl);
   let getTokenPromise;
-  let lastTokenCheckAt = new Date('1970-01-01T00:00:00');
+  let lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
   let cachedToken;
   const getDbAuthUrl = () => {
     if (dbAuthUrl) {
@@ -47,43 +37,34 @@ function createDbAuthClient({
     return fetch(...params);
   };
   const isTokenCacheExpired = () => {
-    const now = new Date();
+    const now = /* @__PURE__ */ new Date();
     return now.getTime() - lastTokenCheckAt.getTime() > TOKEN_CACHE_TIME;
   };
   const resetTokenCache = () => {
-    lastTokenCheckAt = new Date('1970-01-01T00:00:00');
+    lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
     cachedToken = null;
   };
-  const forgotPassword = async username => {
+  const forgotPassword = async (username) => {
     const response = await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: (0, _stringify.default)({
-        username,
-        method: 'forgotPassword'
-      })
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, method: "forgotPassword" })
     });
     return response.json();
   };
   const getToken = async () => {
-    // Middleware auth providers doesn't need a token
     if (middleware) {
       return null;
     }
-
-    // Return the existing fetch promise, so that parallel calls
-    // to getToken only cause a single fetch
     if (getTokenPromise) {
       return getTokenPromise;
     }
     if (isTokenCacheExpired()) {
       getTokenPromise = fetch(`${getDbAuthUrl()}?method=getToken`, {
         credentials
-      }).then(response => response.text()).then(tokenText => {
-        lastTokenCheckAt = new Date();
+      }).then((response) => response.text()).then((tokenText) => {
+        lastTokenCheckAt = /* @__PURE__ */ new Date();
         cachedToken = tokenText.length === 0 ? null : tokenText;
         return cachedToken;
       }).catch(() => {
@@ -95,86 +76,56 @@ function createDbAuthClient({
     }
     return cachedToken;
   };
-  const login = async ({
-    username,
-    password
-  }) => {
+  const login = async ({ username, password }) => {
     const response = await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: (0, _stringify.default)({
-        username,
-        password,
-        method: 'login'
-      })
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, password, method: "login" })
     });
     return response.json();
   };
   const logout = async () => {
     await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      body: (0, _stringify.default)({
-        method: 'logout'
-      })
+      method: "POST",
+      body: JSON.stringify({ method: "logout" })
     });
     return true;
   };
-  const resetPassword = async attributes => {
+  const resetPassword = async (attributes) => {
     const response = await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: (0, _stringify.default)({
-        ...attributes,
-        method: 'resetPassword'
-      })
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "resetPassword" })
     });
     return response.json();
   };
-  const signup = async attributes => {
+  const signup = async (attributes) => {
     const response = await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: (0, _stringify.default)({
-        ...attributes,
-        method: 'signup'
-      })
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "signup" })
     });
     return response.json();
   };
-  const validateResetToken = async resetToken => {
+  const validateResetToken = async (resetToken) => {
     const response = await resetAndFetch(getDbAuthUrl(), {
       credentials,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: (0, _stringify.default)({
-        resetToken,
-        method: 'validateResetToken'
-      })
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ resetToken, method: "validateResetToken" })
     });
     return response.json();
   };
-
-  /**
-   * dbAuth doesn't implement the concept of userMetadata. We used to return the
-   * token (i.e. userId) as the userMetadata.
-   */
   const getUserMetadata = async () => {
-    return middleware ? () => {} : getToken();
+    return middleware ? () => {
+    } : getToken();
   };
   return {
-    type: 'dbAuth',
+    type: "dbAuth",
     client: webAuthn,
     login,
     logout,
@@ -190,4 +141,8 @@ function createDbAuthClient({
     // This is so that we can skip fetching getCurrentUser in reauthenticate
     middlewareAuthEnabled: middleware
   };
-}
+}
+export {
+  createAuth,
+  createDbAuthClient
+};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './dbAuth';
+export * from './dbAuth.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/index.js

@@ -1,20 +1 @@
-"use strict";
-
-var _context;
-var _Object$defineProperty = require("@babel/runtime-corejs3/core-js/object/define-property");
-var _forEachInstanceProperty = require("@babel/runtime-corejs3/core-js/instance/for-each");
-var _Object$keys = require("@babel/runtime-corejs3/core-js/object/keys");
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-var _dbAuth = require("./dbAuth");
-_forEachInstanceProperty(_context = _Object$keys(_dbAuth)).call(_context, function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _dbAuth[key]) return;
-  _Object$defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _dbAuth[key];
-    }
-  });
-});
+export * from "./dbAuth.js";

package/dist/webAuthn.d.ts

@@ -2,7 +2,7 @@ export default class WebAuthnClient {
     authApiUrl: string;
     private getAuthApiUrl;
     setAuthApiUrl(authApiUrl?: string): void;
-    isSupported(): Promise<boolean>;
+    isSupported(): Promise<any>;
     isEnabled(): boolean;
     private authenticationOptions;
     authenticate(): Promise<boolean>;

package/dist/webAuthn.js

@@ -1,47 +1,37 @@
-"use strict";
-
-var _Object$defineProperty = require("@babel/runtime-corejs3/core-js/object/define-property");
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js/json/stringify"));
-require("core-js/modules/esnext.json.parse.js");
 class WebAuthnRegistrationError extends Error {
   constructor(message) {
     super(message);
-    this.name = 'WebAuthnRegistrationError';
+    this.name = "WebAuthnRegistrationError";
   }
 }
 class WebAuthnAuthenticationError extends Error {
   constructor(message) {
     super(message);
-    this.name = 'WebAuthnAuthenticationError';
+    this.name = "WebAuthnAuthenticationError";
   }
 }
 class WebAuthnAlreadyRegisteredError extends WebAuthnRegistrationError {
   constructor() {
-    super('This device is already registered');
-    this.name = 'WebAuthnAlreadyRegisteredError';
+    super("This device is already registered");
+    this.name = "WebAuthnAlreadyRegisteredError";
   }
 }
 class WebAuthnDeviceNotFoundError extends WebAuthnAuthenticationError {
   constructor() {
-    super('WebAuthn device not found');
-    this.name = 'WebAuthnDeviceNotFoundError';
+    super("WebAuthn device not found");
+    this.name = "WebAuthnDeviceNotFoundError";
   }
 }
 class WebAuthnNoAuthenticatorError extends WebAuthnAuthenticationError {
   constructor() {
-    super("This device was not recognized. Use username/password login, or if you're using iOS you can try reloading this page");
-    this.name = 'WebAuthnNoAuthenticatorError';
+    super(
+      "This device was not recognized. Use username/password login, or if you're using iOS you can try reloading this page"
+    );
+    this.name = "WebAuthnNoAuthenticatorError";
   }
 }
 class WebAuthnClient {
-  constructor() {
-    this.authApiUrl = '';
-  }
+  authApiUrl = "";
   getAuthApiUrl() {
     return this.authApiUrl || `${RWJS_API_URL}/auth`;
   }
@@ -51,13 +41,11 @@ class WebAuthnClient {
     }
   }
   async isSupported() {
-    const {
-      browserSupportsWebAuthn
-    } = await import('@simplewebauthn/browser');
+    const { browserSupportsWebAuthn } = await import("@simplewebauthn/browser");
     return browserSupportsWebAuthn();
   }
   isEnabled() {
-    if (typeof window === 'undefined') {
+    if (typeof window === "undefined") {
       return false;
     }
     return !!/\bwebAuthn\b/.test(document.cookie);
@@ -67,47 +55,61 @@ class WebAuthnClient {
     try {
       const xhr = new XMLHttpRequest();
       xhr.withCredentials = true;
-      xhr.open('GET', `${this.getAuthApiUrl()}?method=webAuthnAuthOptions`, false);
-      xhr.setRequestHeader('content-type', 'application/json');
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnAuthOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
       xhr.send(null);
       options = JSON.parse(xhr.responseText);
       if (xhr.status !== 200) {
         if (options.error?.match(/username and password/)) {
           throw new WebAuthnDeviceNotFoundError();
         } else {
-          throw new WebAuthnAuthenticationError(`Could not start authentication: ${options.error}`);
+          throw new WebAuthnAuthenticationError(
+            `Could not start authentication: ${options.error}`
+          );
         }
       }
     } catch (e) {
       console.error(e.message);
-      throw new WebAuthnAuthenticationError(`Could not start authentication: ${e.message}`);
+      throw new WebAuthnAuthenticationError(
+        `Could not start authentication: ${e.message}`
+      );
     }
     return options;
   }
   async authenticate() {
     const authOptions = await this.authenticationOptions();
-    const {
-      startAuthentication
-    } = await import('@simplewebauthn/browser');
+    const { startAuthentication } = await import("@simplewebauthn/browser");
     try {
       const browserResponse = await startAuthentication(authOptions);
       const xhr = new XMLHttpRequest();
       xhr.withCredentials = true;
-      xhr.open('POST', this.getAuthApiUrl(), false);
-      xhr.setRequestHeader('content-type', 'application/json');
-      xhr.send((0, _stringify.default)({
-        method: 'webAuthnAuthenticate',
-        ...browserResponse
-      }));
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(
+        JSON.stringify({
+          method: "webAuthnAuthenticate",
+          ...browserResponse
+        })
+      );
       const options = JSON.parse(xhr.responseText);
       if (xhr.status !== 200) {
-        throw new WebAuthnAuthenticationError(`Could not complete authentication: ${options.error}`);
+        throw new WebAuthnAuthenticationError(
+          `Could not complete authentication: ${options.error}`
+        );
       }
     } catch (e) {
-      if (e.message.match(/No available authenticator recognized any of the allowed credentials/)) {
+      if (e.message.match(
+        /No available authenticator recognized any of the allowed credentials/
+      )) {
         throw new WebAuthnNoAuthenticatorError();
       } else {
-        throw new WebAuthnAuthenticationError(`Error while authenticating: ${e.message}`);
+        throw new WebAuthnAuthenticationError(
+          `Error while authenticating: ${e.message}`
+        );
       }
     }
     return true;
@@ -117,51 +119,62 @@ class WebAuthnClient {
     try {
       const xhr = new XMLHttpRequest();
       xhr.withCredentials = true;
-      xhr.open('GET', `${this.getAuthApiUrl()}?method=webAuthnRegOptions`, false);
-      xhr.setRequestHeader('content-type', 'application/json');
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnRegOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
       xhr.send(null);
       options = JSON.parse(xhr.responseText);
       if (xhr.status !== 200) {
-        throw new WebAuthnRegistrationError(`Could not start registration: ${options.error}`);
+        throw new WebAuthnRegistrationError(
+          `Could not start registration: ${options.error}`
+        );
       }
     } catch (e) {
       console.error(e);
-      throw new WebAuthnRegistrationError(`Could not start registration: ${e.message}`);
+      throw new WebAuthnRegistrationError(
+        `Could not start registration: ${e.message}`
+      );
     }
     return options;
   }
   async register() {
     const options = await this.registrationOptions();
     let regResponse;
-    const {
-      startRegistration
-    } = await import('@simplewebauthn/browser');
+    const { startRegistration } = await import("@simplewebauthn/browser");
     try {
       regResponse = await startRegistration(options);
     } catch (e) {
-      if (e.name === 'InvalidStateError') {
+      if (e.name === "InvalidStateError") {
         throw new WebAuthnAlreadyRegisteredError();
       } else {
-        throw new WebAuthnRegistrationError(`Error while registering: ${e.message}`);
+        throw new WebAuthnRegistrationError(
+          `Error while registering: ${e.message}`
+        );
       }
     }
     try {
       const xhr = new XMLHttpRequest();
       xhr.withCredentials = true;
-      xhr.open('POST', this.getAuthApiUrl(), false);
-      xhr.setRequestHeader('content-type', 'application/json');
-      xhr.send((0, _stringify.default)({
-        method: 'webAuthnRegister',
-        ...regResponse
-      }));
-      const options = JSON.parse(xhr.responseText);
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(JSON.stringify({ method: "webAuthnRegister", ...regResponse }));
+      const options2 = JSON.parse(xhr.responseText);
       if (xhr.status !== 200) {
-        throw new WebAuthnRegistrationError(`Could not complete registration: ${options.error}`);
+        throw new WebAuthnRegistrationError(
+          `Could not complete registration: ${options2.error}`
+        );
       }
     } catch (e) {
-      throw new WebAuthnRegistrationError(`Error while registering: ${e.message}`);
+      throw new WebAuthnRegistrationError(
+        `Error while registering: ${e.message}`
+      );
     }
     return true;
   }
 }
-exports.default = WebAuthnClient;
+export {
+  WebAuthnClient as default
+};

package/package.json

@@ -1,45 +1,62 @@
 {
   "name": "@cedarjs/auth-dbauth-web",
-  "version": "0.5.1-next.0+9c48e99f3",
+  "version": "0.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
     "directory": "packages/auth-providers/dbAuth/web"
   },
   "license": "MIT",
-  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "default": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "webAuthn"
   ],
   "scripts": {
-    "build": "yarn build:js && yarn build:types",
-    "build:js": "babel src -d dist --extensions \".js,.jsx,.ts,.tsx\" --copy-files --no-copy-ignored",
+    "build": "tsx ./build.ts",
     "build:pack": "yarn pack -o cedarjs-auth-dbauth-web.tgz",
-    "build:types": "tsc --build --verbose",
+    "build:types": "tsc --build --verbose ./tsconfig.build.json",
+    "build:types-cjs": "tsc --build --verbose ./tsconfig.cjs.json",
     "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx,template\" --ignore dist --exec \"yarn build\"",
+    "check:attw": "yarn rw-fwtools-attw",
+    "check:package": "concurrently npm:check:attw yarn:publint",
     "prepublishOnly": "NODE_ENV=production yarn build",
-    "test": "yarn vitest run src",
-    "test:watch": "yarn test --watch"
+    "test": "vitest run",
+    "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@babel/runtime-corejs3": "7.27.6",
-    "@cedarjs/auth": "0.5.1-next.0+9c48e99f3",
-    "@simplewebauthn/browser": "7.4.0",
-    "core-js": "3.42.0"
+    "@cedarjs/auth": "0.6.0",
+    "@simplewebauthn/browser": "7.4.0"
   },
   "devDependencies": {
-    "@babel/cli": "7.27.2",
-    "@babel/core": "^7.26.10",
+    "@arethetypeswrong/cli": "0.18.2",
+    "@cedarjs/framework-tools": "0.6.0",
     "@simplewebauthn/typescript-types": "7.4.0",
     "@types/react": "^18.2.55",
+    "concurrently": "8.2.2",
+    "publint": "0.3.12",
     "react": "18.3.1",
+    "tsx": "4.20.3",
     "typescript": "5.6.2",
     "vitest": "3.2.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9c48e99f37468ae011bc39c5d405044ccef0e77c"
+  "gitHead": "dbb79eb24110276fc52803bb3874acd62b76f7c8"
 }

package/webAuthn/index.js

@@ -1,2 +1,3 @@
 /* eslint-env es6, commonjs */
-module.exports = require('../dist/webAuthn')
+// For CommonJS environments, point to the CJS build
+module.exports = require('../dist/cjs/webAuthn')

package/webAuthn/package.json

@@ -1,4 +1,4 @@
 {
   "main": "./index.js",
-  "types": "../dist/webAuthn.d.ts"
+  "types": "../dist/cjs/webAuthn.d.ts"
 }