@joystick.js/node-canary 0.0.0-canary.42 → 0.0.0-canary.420

package/dist/app/runSetter.js

@@ -1,103 +0,0 @@
-import validate from "../validation/index.js";
-import formatAPIError from "../lib/formatAPIError.js";
-import { isObject } from "../validation/lib/typeValidators.js";
-import getOutput from "./getOutput.js";
-import sanitizeAPIResponse from "./sanitizeAPIResponse.js";
-const handleRunSetter = async (setterOptions = {}, input = {}, output = {}, context = {}, APIOptions = {}) => {
-  try {
-    const shouldDisableSanitizationForSetter = setterOptions?.sanitize === false;
-    const shouldSanitizeOutput = (setterOptions?.sanitize || APIOptions?.sanitize) === true || isObject(APIOptions?.sanitize || setterOptions?.sanitize);
-    const data = await setterOptions?.set(input, context) || {};
-    const response = output ? getOutput(data, output) : data;
-    return !shouldDisableSanitizationForSetter && shouldSanitizeOutput ? sanitizeAPIResponse(response, setterOptions?.sanitize || APIOptions?.sanitize) : response;
-  } catch (exception) {
-    throw new Error(`[runSetter.handleRunSetter] ${exception.message}`);
-  }
-};
-const handleRunAuthorization = async (getterOptions = {}, input = {}, context = {}) => {
-  try {
-    const authorization = await getterOptions?.authorized(input, context);
-    if (typeof authorization === "boolean") {
-      return authorization;
-    }
-    if (typeof authorization === "object" && !Array.isArray(authorization) && typeof authorization?.authorized !== "undefined") {
-      return authorization?.authorized ? true : authorization?.message;
-    }
-  } catch (exception) {
-    throw new Error(`[runSetter.runAuthorization] ${exception.message}`);
-  }
-};
-const handleLogValidationErrors = (validationErrors = [], setterName = "") => {
-  try {
-    console.log(`Input validation for setter "${setterName}" failed with the following errors:
-`);
-    for (let i = 0; i < validationErrors?.length; i += 1) {
-      const validationError = validationErrors[i];
-      console.log(`${i + 1}. ${validationError}`);
-    }
-  } catch (exception) {
-    throw new Error(`[runSetter.handleLogValidationErrors] ${exception.message}`);
-  }
-};
-const handleRunValidation = async (input = {}, setterOptions = {}) => {
-  try {
-    let validationErrors = [];
-    if (Object.keys(setterOptions?.input || {})?.length > 0) {
-      validationErrors = await validate.inputWithSchema(input, setterOptions.input);
-    }
-    return validationErrors;
-  } catch (exception) {
-    throw new Error(`[runSetter.runValidation] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.setterName)
-      throw new Error("options.setterName is required.");
-    if (!options.setterOptions)
-      throw new Error("options.setterOptions is required.");
-  } catch (exception) {
-    throw new Error(`[runSetter.validateOptions] ${exception.message}`);
-  }
-};
-const runSetter = async (options, { resolve, reject }) => {
-  try {
-    validateOptions(options);
-    if (Object?.keys(options?.setterOptions?.input || {})?.length > 0) {
-      const validationErrors = await handleRunValidation(options?.input, options?.setterOptions);
-      if (validationErrors?.length > 0) {
-        handleLogValidationErrors(validationErrors, options?.setterName);
-        return reject({
-          errors: validationErrors.map((error) => {
-            return formatAPIError(new Error(error), `setters.${options?.setterName}.validation`, 401);
-          })
-        });
-      }
-    }
-    if (typeof options?.setterOptions?.authorized === "function") {
-      const authorized = await handleRunAuthorization(options?.setterOptions, options?.input, options?.context);
-      if (!authorized || typeof authorized === "string") {
-        return reject({
-          errors: [
-            formatAPIError(new Error(typeof authorized === "string" ? authorized : `Not authorized to access ${options?.setterName}.`), `setters.${options?.setterName}.authorized`, 403)
-          ]
-        });
-      }
-    }
-    if (typeof options?.setterOptions?.set === "function") {
-      const response = await handleRunSetter(options?.setterOptions, options?.input, options?.output, options?.context, options?.APIOptions);
-      return resolve(response);
-    }
-    resolve();
-  } catch (exception) {
-    reject(`[runSetter] ${exception.message}`);
-  }
-};
-var runSetter_default = (options) => new Promise((resolve, reject) => {
-  runSetter(options, { resolve, reject });
-});
-export {
-  runSetter_default as default
-};

package/dist/app/runUploader.js

@@ -1,143 +0,0 @@
-import fs from "fs";
-import AWS from "aws-sdk";
-import path from "path";
-import emitWebsocketEvent from "../websockets/emitWebsocketEvent";
-const uploadToS3 = (upload = {}, options = {}, onUploadProgress) => {
-  try {
-    return new Promise((resolve) => {
-      const temporaryFilePath = `.joystick/uploads/_tmp/${upload?.fileName}`;
-      if (!fs.existsSync(".joystick/uploads/_tmp")) {
-        fs.mkdirSync(".joystick/uploads/_tmp", { recursive: true });
-      }
-      const uploadParams = {
-        Bucket: upload?.s3?.bucket,
-        Key: upload?.fileName,
-        Body: upload?.content
-      };
-      if (upload?.fileName?.includes(".svg")) {
-        uploadParams.ContentType = "image/svg+xml";
-      }
-      if (upload?.s3?.acl) {
-        uploadParams.ACL = upload?.s3?.acl;
-      }
-      const s3 = new AWS.S3({
-        accessKeyId: upload?.s3?.accessKeyId,
-        secretAccessKey: upload?.s3?.secretAccessKey,
-        region: upload?.s3?.region
-      });
-      const s3Upload = s3.upload(uploadParams, {
-        partSize: 5 * 1024 * 1024,
-        queueSize: 3
-      });
-      let previous = 0;
-      s3Upload.on("httpUploadProgress", (s3UploadProgress) => {
-        onUploadProgress("s3", s3UploadProgress?.loaded - previous);
-        previous = s3UploadProgress?.loaded;
-      });
-      s3Upload.send((error, data) => {
-        if (error) {
-          console.warn(error);
-        }
-        fs.unlink(temporaryFilePath, () => {
-          const response = {
-            id: options?.req?.headers["x-joystick-upload-id"],
-            provider: "s3",
-            url: data?.Location,
-            size: upload?.fileSize,
-            fileName: upload?.fileName,
-            originalFileName: upload?.originalFileName,
-            mimeType: upload?.mimeType
-          };
-          if (error) {
-            response.error = error?.message || "There was an error uploading your file to Amazon S3. Check the server logs for more information.";
-          }
-          resolve(response);
-        });
-      });
-    });
-  } catch (exception) {
-    throw new Error(`[runUploader.uploadToS3] ${exception.message}`);
-  }
-};
-const uploadToLocal = (upload = {}, options = {}) => {
-  try {
-    return new Promise((resolve) => {
-      if (upload?.local?.path) {
-        if (!fs.existsSync(upload?.local?.path)) {
-          fs.mkdirSync(upload?.local?.path, { recursive: true });
-        }
-        const directoryPath = path.dirname(`${upload?.local?.path}/${upload?.fileName}`);
-        if (!fs.existsSync(directoryPath)) {
-          fs.mkdirSync(directoryPath, { recursive: true });
-        }
-        const filePath = `${upload?.local?.path}/${upload?.fileName}` || `./_uploads/${upload?.fileName}`;
-        fs.writeFile(filePath, upload?.content, () => {
-          resolve({
-            id: options?.req?.headers["x-joystick-upload-id"],
-            provider: "local",
-            url: filePath,
-            size: upload?.fileSize,
-            fileName: upload?.fileName,
-            originalFileName: upload?.originalFileName,
-            mimeType: upload?.mimeType
-          });
-        });
-      }
-    });
-  } catch (exception) {
-    throw new Error(`[runUploader.uploadToLocal] ${exception.message}`);
-  }
-};
-const handleUploads = async (options = {}) => {
-  try {
-    const uploads = [];
-    let alreadyUploaded = options?.alreadyUploaded;
-    const onUploadProgress = (provider = "", chunk = 0) => {
-      const progress = alreadyUploaded + chunk;
-      const percentage = Math.round(progress / options?.totalFileSizeAllProviders * 100);
-      emitWebsocketEvent(`uploaders_${options?.req?.headers["x-joystick-upload-id"]}`, "progress", { provider, progress: percentage });
-      alreadyUploaded += chunk;
-    };
-    for (let i = 0; i < options?.uploads?.length; i += 1) {
-      const upload = options?.uploads[i];
-      if (upload?.providers?.includes("local")) {
-        const result = await uploadToLocal(upload, { ...options });
-        uploads.push(result);
-      }
-      if (upload?.providers?.includes("s3")) {
-        const result = await uploadToS3(upload, { ...options }, onUploadProgress);
-        uploads.push(result);
-      }
-    }
-    return uploads;
-  } catch (exception) {
-    throw new Error(`[runUploader.handleUploads] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.uploads)
-      throw new Error("options.uploads is required.");
-    if (!options.req)
-      throw new Error("options.req is required.");
-  } catch (exception) {
-    throw new Error(`[runUploader.validateOptions] ${exception.message}`);
-  }
-};
-const runUploader = async (options, promise = {}) => {
-  try {
-    validateOptions(options);
-    const completedUploads = await handleUploads(options);
-    promise.resolve(completedUploads);
-  } catch (exception) {
-    promise.reject(exception.message);
-  }
-};
-var runUploader_default = (options) => new Promise((resolve, reject) => {
-  runUploader(options, { resolve, reject });
-});
-export {
-  runUploader_default as default
-};

package/dist/app/sanitizeAPIResponse.js

@@ -1,27 +0,0 @@
-import util from "util";
-import escapeHTML from "../lib/escapeHTML.js";
-const sanitizeAPIResponse = (data = null) => {
-  let sanitizedData = data;
-  if (!util.isString(sanitizedData) && !util.isObject(sanitizedData) && !Array.isArray(sanitizedData)) {
-    return sanitizedData;
-  }
-  if (util.isString(sanitizedData)) {
-    sanitizedData = escapeHTML(sanitizedData)?.trim();
-  }
-  if (util.isObject(sanitizedData) && !Array.isArray(sanitizedData)) {
-    sanitizedData = Object.entries(sanitizedData)?.reduce((result = {}, [key, value]) => {
-      result[key] = sanitizeAPIResponse(value);
-      return result;
-    }, {});
-  }
-  if (Array.isArray(sanitizedData)) {
-    sanitizedData = sanitizedData.map((arrayItem = null) => {
-      return sanitizeAPIResponse(arrayItem);
-    });
-  }
-  return sanitizedData;
-};
-var sanitizeAPIResponse_default = sanitizeAPIResponse;
-export {
-  sanitizeAPIResponse_default as default
-};

package/dist/app/utils/process.js

@@ -1,193 +0,0 @@
-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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __reExport = (target, module, desc) => {
-  if (module && typeof module === "object" || typeof module === "function") {
-    for (let key of __getOwnPropNames(module))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toModule = (module) => {
-  return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
-};
-
-// node_modules/process/browser.js
-var require_browser = __commonJS({
-  "node_modules/process/browser.js"(exports, module) {
-    var process2 = module.exports = {};
-    var cachedSetTimeout;
-    var cachedClearTimeout;
-    function defaultSetTimout() {
-      throw new Error("setTimeout has not been defined");
-    }
-    function defaultClearTimeout() {
-      throw new Error("clearTimeout has not been defined");
-    }
-    (function() {
-      try {
-        if (typeof setTimeout === "function") {
-          cachedSetTimeout = setTimeout;
-        } else {
-          cachedSetTimeout = defaultSetTimout;
-        }
-      } catch (e) {
-        cachedSetTimeout = defaultSetTimout;
-      }
-      try {
-        if (typeof clearTimeout === "function") {
-          cachedClearTimeout = clearTimeout;
-        } else {
-          cachedClearTimeout = defaultClearTimeout;
-        }
-      } catch (e) {
-        cachedClearTimeout = defaultClearTimeout;
-      }
-    })();
-    function runTimeout(fun) {
-      if (cachedSetTimeout === setTimeout) {
-        return setTimeout(fun, 0);
-      }
-      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-        cachedSetTimeout = setTimeout;
-        return setTimeout(fun, 0);
-      }
-      try {
-        return cachedSetTimeout(fun, 0);
-      } catch (e) {
-        try {
-          return cachedSetTimeout.call(null, fun, 0);
-        } catch (e2) {
-          return cachedSetTimeout.call(this, fun, 0);
-        }
-      }
-    }
-    function runClearTimeout(marker) {
-      if (cachedClearTimeout === clearTimeout) {
-        return clearTimeout(marker);
-      }
-      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-        cachedClearTimeout = clearTimeout;
-        return clearTimeout(marker);
-      }
-      try {
-        return cachedClearTimeout(marker);
-      } catch (e) {
-        try {
-          return cachedClearTimeout.call(null, marker);
-        } catch (e2) {
-          return cachedClearTimeout.call(this, marker);
-        }
-      }
-    }
-    var queue = [];
-    var draining = false;
-    var currentQueue;
-    var queueIndex = -1;
-    function cleanUpNextTick() {
-      if (!draining || !currentQueue) {
-        return;
-      }
-      draining = false;
-      if (currentQueue.length) {
-        queue = currentQueue.concat(queue);
-      } else {
-        queueIndex = -1;
-      }
-      if (queue.length) {
-        drainQueue();
-      }
-    }
-    function drainQueue() {
-      if (draining) {
-        return;
-      }
-      var timeout = runTimeout(cleanUpNextTick);
-      draining = true;
-      var len = queue.length;
-      while (len) {
-        currentQueue = queue;
-        queue = [];
-        while (++queueIndex < len) {
-          if (currentQueue) {
-            currentQueue[queueIndex].run();
-          }
-        }
-        queueIndex = -1;
-        len = queue.length;
-      }
-      currentQueue = null;
-      draining = false;
-      runClearTimeout(timeout);
-    }
-    process2.nextTick = function(fun) {
-      var args = new Array(arguments.length - 1);
-      if (arguments.length > 1) {
-        for (var i = 1; i < arguments.length; i++) {
-          args[i - 1] = arguments[i];
-        }
-      }
-      queue.push(new Item(fun, args));
-      if (queue.length === 1 && !draining) {
-        runTimeout(drainQueue);
-      }
-    };
-    function Item(fun, array) {
-      this.fun = fun;
-      this.array = array;
-    }
-    Item.prototype.run = function() {
-      this.fun.apply(null, this.array);
-    };
-    process2.title = "browser";
-    process2.browser = true;
-    process2.env = {};
-    process2.argv = [];
-    process2.version = "";
-    process2.versions = {};
-    function noop() {
-    }
-    process2.on = noop;
-    process2.addListener = noop;
-    process2.once = noop;
-    process2.off = noop;
-    process2.removeListener = noop;
-    process2.removeAllListeners = noop;
-    process2.emit = noop;
-    process2.prependListener = noop;
-    process2.prependOnceListener = noop;
-    process2.listeners = function(name) {
-      return [];
-    };
-    process2.binding = function(name) {
-      throw new Error("process.binding is not supported");
-    };
-    process2.cwd = function() {
-      return "/";
-    };
-    process2.chdir = function(dir) {
-      throw new Error("process.chdir is not supported");
-    };
-    process2.umask = function() {
-      return 0;
-    };
-  }
-});
-
-// src/app/utils/process.js
-var import_browser = __toModule(require_browser());
-window.process = import_browser.default;
-var env = {
-  NODE_ENV: "${NODE_ENV}"
-};
-if (window.process) {
-  window.process.env = env;
-}

package/dist/app/validateSession.js

@@ -1,16 +0,0 @@
-import formatAPIError from "../lib/formatAPIError.js";
-var validateSession_default = (req = null, res = null, sessions = null) => {
-  const sessionToken = req?.cookies?.joystickSession;
-  const csrfToken = req?.headers["x-joystick-csrf"];
-  const session = sessions?.get(sessionToken);
-  if (!session || session && session.csrf !== csrfToken) {
-    res.status(403).send(JSON.stringify({
-      errors: [formatAPIError(new Error("Unauthorized request."))]
-    }));
-    return false;
-  }
-  return true;
-};
-export {
-  validateSession_default as default
-};

package/dist/app/validateUploaderOptions.js

@@ -1,53 +0,0 @@
-const allowedOptions = [
-  "mimeTypes",
-  "maxSizeInMegabytes",
-  "fileName",
-  "providers",
-  "local",
-  "s3",
-  "onBeforeUpload",
-  "onAfterUpload"
-];
-const allowedLocalOptions = [
-  "path"
-];
-const allowedS3Options = [
-  "region",
-  "accessKeyId",
-  "secretAccessKey",
-  "bucket",
-  "acl"
-];
-var validateUploaderOptions_default = (options = {}) => {
-  const errors = [];
-  const optionNames = Object.keys(options);
-  optionNames.forEach((optionName) => {
-    if (!allowedOptions.includes(optionName)) {
-      errors.push(`${optionName} is not an allowed uploader option.`);
-    }
-  });
-  if (options?.providers?.includes("local") && !options?.local) {
-    errors.push(`If an uploader provider is 'local', local object must be specified in options with a storage path.`);
-  }
-  if (options?.providers?.includes("s3") && !options?.s3) {
-    errors.push(`If an uploader provider is 's3', s3 object must be specified with configuration.`);
-  }
-  if (options?.provider?.includes("local") && options.local) {
-    Object.keys(options.local).forEach((optionName) => {
-      if (!allowedLocalOptions.includes(optionName)) {
-        errors.push(`local.${optionName} is not an allowed uploader option.`);
-      }
-    });
-  }
-  if (options?.provider?.includes("s3") && options.s3) {
-    Object.keys(options.s3).forEach((optionName) => {
-      if (!allowedS3Options.includes(optionName)) {
-        errors.push(`s3.${optionName} is not an allowed uploader option.`);
-      }
-    });
-  }
-  return errors;
-};
-export {
-  validateUploaderOptions_default as default
-};

package/dist/app/validateUploads.js

@@ -1,102 +0,0 @@
-import log from "../lib/log";
-const handleCheckUpload = ({
-  uploaderName,
-  maxSizeInMegabytes,
-  mimeTypes,
-  originalFileName,
-  fileSize,
-  mimeType
-}) => {
-  try {
-    const maxSizeInBytes = maxSizeInMegabytes * 1024 * 1024;
-    const errors = [];
-    if (maxSizeInBytes && !isNaN(maxSizeInBytes) && fileSize && fileSize > maxSizeInBytes) {
-      const error = `The file ${originalFileName} is too big. Max file size for the uploader ${uploaderName} is ${maxSizeInMegabytes}MB.`;
-      log(error, {
-        level: "danger",
-        docs: "https://github.com/cheatcode/joystick#uploaders"
-      });
-      errors.push({ message: error });
-    }
-    if (mimeTypes?.length > 0 && !mimeTypes.includes(mimeType)) {
-      const error = `The MIME type for the file ${originalFileName} is not supported by the uploader ${uploaderName} (only ${mimeTypes?.join(", ")}).`;
-      log(error, {
-        level: "danger",
-        docs: "https://github.com/cheatcode/joystick#uploaders"
-      });
-      errors.push({ message: error });
-    }
-    return errors;
-  } catch (exception) {
-    throw new Error(`[validateUploads.handleCheckUpload] ${exception.message}`);
-  }
-};
-const handleCheckUploads = (uploads = []) => {
-  try {
-    return uploads.flatMap((upload) => {
-      return handleCheckUpload(upload);
-    });
-  } catch (exception) {
-    throw new Error(`[validateUploads.handleCheckUploads] ${exception.message}`);
-  }
-};
-const formatUploads = ({
-  files: uploads = [],
-  uploaderName = "",
-  uploaderOptions = {},
-  input = {}
-}) => {
-  try {
-    return Promise.all(uploads.map(async (upload) => {
-      const fileExtension = upload?.mimeType?.split("/").pop();
-      return {
-        uploaderName,
-        providers: uploaderOptions?.providers,
-        local: uploaderOptions?.local,
-        s3: uploaderOptions?.s3,
-        maxSizeInMegabytes: typeof uploaderOptions?.maxSizeInMegabytes === "function" ? await uploaderOptions?.maxSizeInMegabytes({ input, upload }) : uploaderOptions?.maxSizeInMegabytes,
-        mimeTypes: uploaderOptions?.mimeTypes,
-        fileName: typeof uploaderOptions?.fileName === "function" ? uploaderOptions.fileName({ input, fileName: upload?.originalname, fileSize: upload?.size, fileExtension, mimeType: upload?.mimetype }) : upload?.originalname,
-        originalFileName: upload?.originalname,
-        fileSize: upload?.size,
-        mimeType: upload?.mimetype,
-        content: upload?.buffer
-      };
-    }));
-  } catch (exception) {
-    throw new Error(`[validateUploads.formatUploads] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.files)
-      throw new Error("options.files is required.");
-    if (!options.uploaderName)
-      throw new Error("options.uploaderName is required.");
-    if (!options.uploaderOptions)
-      throw new Error("options.uploaderOptions is required.");
-  } catch (exception) {
-    throw new Error(`[validateUploads.validateOptions] ${exception.message}`);
-  }
-};
-const validateUploads = async (options, promise = {}) => {
-  try {
-    validateOptions(options);
-    const formattedUploads = await formatUploads(options);
-    const errors = handleCheckUploads(formattedUploads);
-    if (errors?.length > 0) {
-      return promise.reject(errors);
-    }
-    return promise.resolve(formattedUploads);
-  } catch (exception) {
-    promise.reject(exception);
-  }
-};
-var validateUploads_default = (options) => new Promise((resolve, reject) => {
-  validateUploads(options, { resolve, reject });
-});
-export {
-  validateUploads_default as default
-};

package/dist/email/render.js

@@ -1,50 +0,0 @@
-import fs from "fs";
-import ssr from "../ssr";
-import getBuildPath from "../lib/getBuildPath";
-import { isObject } from "../validation/lib/typeValidators";
-const getFile = async (buildPath = "") => {
-  const file = await import(buildPath);
-  return file.default;
-};
-const getTranslations = async (buildPath = "", templateName = "", user = {}, settings = {}) => {
-  const language = user?.language || settings?.config?.i18n?.defaultLanguage;
-  const languageFilePath = `${process.cwd()}/${buildPath}i18n/email/${templateName}_${language}.js`;
-  const hasLanguageFile = fs.existsSync(languageFilePath);
-  if (hasLanguageFile) {
-    const languageFile = await getFile(languageFilePath);
-    const isValidLanguageFile = languageFile && isObject(languageFile);
-    return isValidLanguageFile ? languageFile : {};
-  }
-  return {};
-};
-var render_default = async ({
-  templateName,
-  baseName,
-  settings,
-  Component,
-  props,
-  subject,
-  preheader,
-  user,
-  hmrToken
-}) => {
-  try {
-    const buildPath = getBuildPath();
-    const translations = await getTranslations(buildPath, templateName, user, settings);
-    return ssr({
-      email: true,
-      emailSubject: subject,
-      emailPreheader: preheader,
-      componentFunction: Component,
-      baseEmailHTMLName: baseName,
-      props,
-      translations,
-      hmrToken
-    });
-  } catch (exception) {
-    console.warn(exception);
-  }
-};
-export {
-  render_default as default
-};