@fernir2/saas-kit-cli 0.1.8 → 0.1.9

package/bin/index.js

@@ -1,24 +1,1530 @@
 #!/usr/bin/env node
-import { execSync } from "child_process";
-import { promises as fsPromises, existsSync, mkdirSync, rmSync } from "fs";
-import { fileURLToPath } from "node:url";
-import * as path from "path";
-import fs from "node:fs";
-import { toolsFoldersToReplace, additionalFoldersToCreate } from "../packages/base-repo/constants/create-app-constants.js";
-import { logStringError, logInfoRaw } from "../packages/level2/fd-toolbox/logging/loggers.js";
-import { projectName } from "../packages/level2/fd-toolbox/constants/constants.js";
-import { allFilesToCopy } from "../cli/constants/path.js";
-import { createError } from "../packages/level2/fd-toolbox/errors/errors.js";
-import { folders } from "../packages/base-repo/app-constants/project-paths.js";
-import { npmPackages } from "../packages/base-repo/constants/packages.js";
-import { aliasSymbols } from "../packages/base-repo/app-constants/aliases.js";
-import { isString, isWithIndexer } from "../packages/level2/fd-toolbox/types/ensure-type.js";
+'use strict';
+import { execSync } from 'child_process';
+import { existsSync, rmSync, promises, mkdirSync } from 'fs';
+import { fileURLToPath as fileURLToPath$1 } from 'node:url';
+import * as path from 'path';
+import { join } from 'path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'url';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { toast } from 'sonner';
+import debounce from 'lodash.debounce';
+import { createEnv } from '@t3-oss/env-nextjs';
+import z from 'zod';
+import dotenv from 'dotenv';
+
+const projectPaths = {
+  app: "src/app",
+  apiV1: "src/app/api/v1",
+  toolsNpmCommands: "tools/npm-commands/",
+  tools: "tools/"};
+const folders = {
+  cli: "cli",
+  server: "server",
+  client: "client",
+  packages: "packages",
+  nodeModules: "node_modules",
+  level2: "level2",
+  test: "test"};
+const packagesPath = {
+  packagesClient: `${folders.packages}/${folders.level2}/${folders.client}/`
+};
+const clientPaths = {
+  styles: `${packagesPath.packagesClient}/styles`};
+
+const additionalFoldersToCreate = [folders.server, folders.test];
+const toolsFoldersToReplace = {
+  [projectPaths.toolsNpmCommands]: { [projectPaths.tools]: "" }
+};
+
+const resourceNames = {
+  hint: "Hint",
+  payment: "Payment",
+  subscription: "Subscription"};
+
+const hint = resourceNames.hint.toLowerCase();
+const subscription = resourceNames.subscription.toLowerCase();
+const payment = resourceNames.payment.toLowerCase();
+const apiPathNames = {
+  getOne: join(hint, "getone"),
+  log: "log",
+  paymentVerifyFail: join(payment, "verify-fail"),
+  paymentVerifySuccess: join(payment, "verify-success"),
+  paymentMethod: join(payment, "method"),
+  cancelSubscription: join(subscription, "cancel"),
+  updateSubscription: join(subscription, "update"),
+  createSubscription: join(subscription, "create")};
+
+const logSeverities = {
+  debug: 0,
+  info: 1,
+  warning: 2,
+  error: 3
+};
+
+const appEnvironments = {
+  development: "development",
+  production: "production",
+  test: "test",
+  staging: "staging",
+  demo: "demo"
+};
+const launchMode = {
+  direct: "direct"
+};
+
+const toolboxEnvSettingKeys = {
+  ci: "FD_CI",
+  isWebUiTest: "NEXT_PUBLIC_FD_IS_WEB_UI_TEST",
+  useS3Compatible: "NEXT_PUBLIC_FD_USE_S3_COMPATIBLE",
+  launchMode: "NEXT_PUBLIC_FD_LAUNCH_MODE",
+  appEnv: "FD_APP_ENV",
+  disableWebSockets: "NEXT_PUBLIC_FD_DISABLE_WEBSOCKETS"};
+
+var __defProp$t = Object.defineProperty;
+var __name$t = (target, value) => __defProp$t(target, "name", { value, configurable: true });
+function ensureString(value) {
+  if (isString(value)) {
+    return value;
+  } else {
+    return String(value);
+  }
+}
+__name$t(ensureString, "ensureString");
+function ensureNumber(value) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isString(value)) {
+    return parseFloat(value);
+  } else return NaN;
+}
+__name$t(ensureNumber, "ensureNumber");
+function ensureObjectArray(valueArray) {
+  if (Array.isArray(valueArray) && valueArray.length > 0 && isObject(valueArray[0])) {
+    const objectArray = [];
+    for (const value of valueArray) {
+      if (isObject(value)) objectArray.push(value);
+    }
+    return objectArray;
+  }
+  return [];
+}
+__name$t(ensureObjectArray, "ensureObjectArray");
+function ensureWithIndexer(value) {
+  let withIndexer = {};
+  if (isWithIndexer(value)) {
+    withIndexer = value;
+  }
+  return withIndexer;
+}
+__name$t(ensureWithIndexer, "ensureWithIndexer");
+const types = {
+  object: "object",
+  string: "string",
+  number: "number"
+};
+const stripeConflictResponseProperties = {
+  detail: "detail"
+};
+function isObject(value) {
+  return typeof value === types.object && value !== null;
+}
+__name$t(isObject, "isObject");
+function isString(value) {
+  return typeof value === types.string;
+}
+__name$t(isString, "isString");
+function isNumber(value) {
+  return typeof value === types.number;
+}
+__name$t(isNumber, "isNumber");
+function isWithIndexer(value) {
+  return isObject(value) && !Array.isArray(value);
+}
+__name$t(isWithIndexer, "isWithIndexer");
+function isArray(value) {
+  return isObject(value) && Array.isArray(value);
+}
+__name$t(isArray, "isArray");
+function isErrorResponseWithDetail(response) {
+  return isObject(response) && stripeConflictResponseProperties.detail in response;
+}
+__name$t(isErrorResponseWithDetail, "isErrorResponseWithDetail");
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+__name$t(isBoolean, "isBoolean");
+
+var __defProp$s = Object.defineProperty;
+var __name$s = (target, value) => __defProp$s(target, "name", { value, configurable: true });
+function createError(message, innerError) {
+  const errorMessage = `${message}
+`;
+  const error = new Error(errorMessage);
+  error.name = "FdError";
+  if (innerError) {
+    error.innerError = innerError;
+  }
+  return error;
+}
+__name$s(createError, "createError");
+
+var __defProp$r = Object.defineProperty;
+var __name$r = (target, value) => __defProp$r(target, "name", { value, configurable: true });
+function notify(message, options) {
+  toast(message, options);
+}
+__name$r(notify, "notify");
+function notifyError(error, duration) {
+  const message = typeof error === "string" ? error : error.message;
+  toast.error(message, {
+    duration
+  });
+}
+__name$r(notifyError, "notifyError");
+function notifySuccess(message) {
+  const successMessage = message ?? "Success";
+  toast.success(successMessage);
+}
+__name$r(notifySuccess, "notifySuccess");
+function notifyWarning(message) {
+  toast.warning(message);
+}
+__name$r(notifyWarning, "notifyWarning");
+function notifyFailure(message) {
+  const failureMessage = message ?? "An error has occurred";
+  toast.error(failureMessage);
+}
+__name$r(notifyFailure, "notifyFailure");
+const notifyDebouncedError = debounce((message, duration) => {
+  notifyError(message, duration);
+}, 4e3);
+
+var __defProp$q = Object.defineProperty;
+var __name$q = (target, value) => __defProp$q(target, "name", { value, configurable: true });
+function logAndNotify(error) {
+  logErrorRaw(error);
+  if (!isBrowser()) {
+    throw error;
+  } else if (isProd() || isTest()) {
+    notifyDebouncedError("An error has occured. Please try again later or contact support");
+  } else {
+    notifyError(error);
+  }
+}
+__name$q(logAndNotify, "logAndNotify");
+
+const promiseStatuses = {
+  fulfilled: "fulfilled"};
+
+const wellKnownMetaProps = {
+  name: "name"};
+
+const emptyGuid = "00000000-0000-0000-0000-000000000000";
+const projectName = "SaaS Kit";
+
+var __defProp$p = Object.defineProperty;
+var __name$p = (target, value) => __defProp$p(target, "name", { value, configurable: true });
+const isNullOrUndefined = /* @__PURE__ */ __name$p((value) => {
+  return value === null || value === void 0;
+}, "isNullOrUndefined");
+const isEmptyNullOrUndefined = /* @__PURE__ */ __name$p((value) => value === "" || isNullOrUndefined(value) || typeof value === "object" && Object.keys(value).length === 0, "isEmptyNullOrUndefined");
+
+var __defProp$o = Object.defineProperty;
+var __name$o = (target, value) => __defProp$o(target, "name", { value, configurable: true });
+const nameOf = /* @__PURE__ */ __name$o((key) => key.toString(), "nameOf");
+
+var __defProp$n = Object.defineProperty;
+var __name$n = (target, value) => __defProp$n(target, "name", { value, configurable: true });
+const withIdProps = {
+  id: nameOf("id")
+};
+function isResourceWithId(resource) {
+  return resource && typeof resource === "object" && typeof resource.id === "string";
+}
+__name$n(isResourceWithId, "isResourceWithId");
+
+var __defProp$m = Object.defineProperty;
+var __name$m = (target, value) => __defProp$m(target, "name", { value, configurable: true });
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+__name$m(cn, "cn");
+function getSetting(key) {
+  return process.env[key];
+}
+__name$m(getSetting, "getSetting");
+function handleGlobalError(message, _source, _lineno, _colno, error) {
+  if (error) {
+    logAndNotify(error);
+  } else if (typeof message === "string") {
+    logAndNotify(new Error(message));
+  }
+  return true;
+}
+__name$m(handleGlobalError, "handleGlobalError");
+function handlePromiseRejection(event) {
+  logAndNotify(event.reason);
+  return true;
+}
+__name$m(handlePromiseRejection, "handlePromiseRejection");
+function isPlainObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+__name$m(isPlainObject, "isPlainObject");
+function parseJson(value) {
+  const result = JSON.parse(value);
+  return result;
+}
+__name$m(parseJson, "parseJson");
+async function parseJsonBodyFromRequest(req) {
+  const result = await req.json();
+  return result;
+}
+__name$m(parseJsonBodyFromRequest, "parseJsonBodyFromRequest");
+async function getJsonFromResponse(res) {
+  const result = await res.json();
+  return result;
+}
+__name$m(getJsonFromResponse, "getJsonFromResponse");
+function getObjectValues(object) {
+  const values = Object.values(object);
+  return values;
+}
+__name$m(getObjectValues, "getObjectValues");
+function getObjectPropertyKey(object, inputValue) {
+  let result;
+  for (const [key, value] of Object.entries(object)) {
+    if (value === inputValue) result = key;
+  }
+  return result;
+}
+__name$m(getObjectPropertyKey, "getObjectPropertyKey");
+function isPromiseFulfilled(result) {
+  return result.status === promiseStatuses.fulfilled;
+}
+__name$m(isPromiseFulfilled, "isPromiseFulfilled");
+function isWithName(object) {
+  return isObject(object) && hasObjectOwnProperty(object, wellKnownMetaProps.name) && !isEmptyNullOrUndefined(object[wellKnownMetaProps.name]);
+}
+__name$m(isWithName, "isWithName");
+function isWithId(value) {
+  return isObject(value) && !Array.isArray(value) && withIdProps.id in value;
+}
+__name$m(isWithId, "isWithId");
+function hasObjectOwnProperty(obj, prop) {
+  return Object.hasOwn(obj, prop);
+}
+__name$m(hasObjectOwnProperty, "hasObjectOwnProperty");
+function getArrayFromResponse(items) {
+  let result;
+  if (Array.isArray(items)) result = items;
+  else result = items?.data ?? [];
+  return result;
+}
+__name$m(getArrayFromResponse, "getArrayFromResponse");
+
+const envSettingTypes = {
+  string: "string",
+  number: "number",
+  boolean: "boolean"
+};
+
+var __defProp$l = Object.defineProperty;
+var __name$l = (target, value) => __defProp$l(target, "name", { value, configurable: true });
+function getDotenvConfig() {
+  const result = dotenv.config();
+  return result;
+}
+__name$l(getDotenvConfig, "getDotenvConfig");
+
+const stringValueRepresentations = {
+  booleanTrue: "true"
+};
+
+var __defProp$k = Object.defineProperty;
+var __name$k = (target, value) => __defProp$k(target, "name", { value, configurable: true });
+getDotenvConfig();
+const serverEnvSchema = z.object({
+  FD_DATABASE_CONNECTION_STRING: z.string(),
+  FD_EMAIL_SERVICE_URL: z.string(),
+  FD_EMAIL_SERVICE_KEY: z.string(),
+  FD_SEND_EMAILS: z.string().optional().transform(valueToBooleanOrUndefined),
+  FD_PROTOCOL: z.enum(["http", "https"]).default("http"),
+  FD_HOST: z.string().default("localhost"),
+  FD_PORT: z.coerce.number().default(3e3),
+  FD_GITLAB_PRIVATE_TOKEN: z.string().optional(),
+  FD_DEFAULT_BRANCH_NAME: z.string().default("main"),
+  FD_GIT_USERNAME: z.string().optional(),
+  FD_GIT_PASSWORD: z.string().optional(),
+  FD_GOOGLE_PLACES_API_KEY: z.string(),
+  FD_STRIPE_SECRET_KEY: z.string(),
+  FD_INTEGRATION_ENABLED: optionalBooleanWithDefault(true),
+  FD_USE_MIGRATIONS: optionalBooleanWithDefault(false),
+  FD_SEED_DEV_RESOURCES: optionalBooleanWithDefault(true),
+  FD_SEED_DEMO_RESOURCES: optionalBooleanWithDefault(true),
+  FD_AI_API_KEY: z.string(),
+  FD_SCREENSHOT_ONE_ACCESS_KEY: z.string(),
+  FD_SCREENSHOT_ONE_SECRET_KEY: z.string(),
+  FD_S3_COMPATIBLE_ACCESS_KEY: z.string(),
+  FD_S3_COMPATIBLE_SECRET_ACCESS_KEY: z.string(),
+  FD_S3_COMPATIBLE_BUCKET_NAME: z.string(),
+  FD_S3_COMPATIBLE_ENDPOINT: z.string(),
+  FD_S3_COMPATIBLE_ENDPOINT_DEV: z.string(),
+  FD_GITLAB_PROJECT_ID: z.string().optional(),
+  FD_GITLAB_HOST: z.string().optional(),
+  FD_REPO_OWNER: z.string().optional(),
+  FD_REPO_NAME: z.string().optional(),
+  FD_GOOGLE_SPREADSHEET_ID: z.string().optional(),
+  FD_GOOGLE_SPREADSHEET_SHEET_NAME: z.string().optional(),
+  FD_GOOGLE_CLIENT_ID: z.string().optional(),
+  FD_SENDER_EMAIL: z.string().optional(),
+  FD_CI: optionalBooleanWithDefault(false),
+  FD_PLAID_CLIENT_ID: z.string().optional(),
+  FD_PLAID_SECRET: z.string().optional(),
+  FD_PLAID_ENV: z.string().optional(),
+  FD_APP_ENV: z.string().optional(),
+  FD_STORE_SESSION_IN_HEADER: optionalBooleanWithDefault(false),
+  FD_SHIPPO_API_KEY: z.string().optional(),
+  FD_FEDEX_API_KEY: z.string().optional(),
+  FD_FEDEX_SECRET_KEY: z.string().optional(),
+  FD_IS_LM: optionalBooleanWithDefault(false),
+  FD_IS_TEST: optionalBooleanWithDefault(false),
+  PLAYWRIGHT_REPORT_DIR: z.string().default("playwright-report"),
+  FD_PROJECT_NAME: z.string().optional().default("SaaS Kit"),
+  FD_SUPPORT_LINK: z.string().optional(),
+  FD_USE_REMOTE_CACHE: optionalBooleanWithDefault(false),
+  FD_REMOTE_CACHE_URL: z.string().optional()
+});
+const clientEnvSchema = z.object({
+  NEXT_PUBLIC_FD_STRIPE_PUBLIC_KEY: z.string(),
+  NEXT_PUBLIC_FD_LAUNCH_MODE: z.enum(["direct", "proxy"]).default("direct"),
+  NEXT_PUBLIC_FD_SEED_DEMO_RESOURCES: optionalBooleanWithDefault(false),
+  NEXT_PUBLIC_FD_IS_WEB_UI_TEST: optionalBooleanWithDefault(false),
+  NEXT_PUBLIC_FD_SHOW_SIDEBAR: optionalBooleanWithDefault(true),
+  NEXT_PUBLIC_FD_USE_S3_COMPATIBLE: optionalBooleanWithDefault(false),
+  NEXT_PUBLIC_FD_BASE_URL: z.string().default("http://localhost:3000"),
+  NEXT_PUBLIC_FD_DISABLE_WEBSOCKETS: optionalBooleanWithDefault(false),
+  NEXT_PUBLIC_FD_GOOGLE_CLIENT_ID: z.string().optional(),
+  NEXT_PUBLIC_FD_GOOGLE_CLIENT_SECRET: z.string().optional(),
+  NEXT_PUBLIC_FD_FACEBOOK_CLIENT_ID: z.string().optional(),
+  NEXT_PUBLIC_FD_FACEBOOK_CLIENT_SECRET: z.string().optional(),
+  NEXT_PUBLIC_FD_MICROSOFT_CLIENT_ID: z.string().optional(),
+  NEXT_PUBLIC_FD_MICROSOFT_CLIENT_SECRET: z.string().optional()
+});
+const runtimeEnvSchema = {
+  NEXT_PUBLIC_FD_STRIPE_PUBLIC_KEY: process.env["NEXT_PUBLIC_FD_STRIPE_PUBLIC_KEY"],
+  NEXT_PUBLIC_FD_LAUNCH_MODE: process.env["NEXT_PUBLIC_FD_LAUNCH_MODE"],
+  NEXT_PUBLIC_FD_SEED_DEMO_RESOURCES: process.env["NEXT_PUBLIC_FD_SEED_DEMO_RESOURCES"],
+  NEXT_PUBLIC_FD_IS_WEB_UI_TEST: process.env["NEXT_PUBLIC_FD_IS_WEB_UI_TEST"],
+  NEXT_PUBLIC_FD_SHOW_SIDEBAR: process.env["NEXT_PUBLIC_FD_SHOW_SIDEBAR"],
+  NEXT_PUBLIC_FD_USE_S3_COMPATIBLE: process.env["NEXT_PUBLIC_FD_USE_S3_COMPATIBLE"],
+  NEXT_PUBLIC_FD_BASE_URL: process.env["NEXT_PUBLIC_FD_BASE_URL"],
+  NEXT_PUBLIC_FD_DISABLE_WEBSOCKETS: process.env["NEXT_PUBLIC_FD_DISABLE_WEBSOCKETS"],
+  NEXT_PUBLIC_FD_GOOGLE_CLIENT_ID: process.env["NEXT_PUBLIC_FD_GOOGLE_CLIENT_ID"],
+  NEXT_PUBLIC_FD_GOOGLE_CLIENT_SECRET: process.env["NEXT_PUBLIC_FD_GOOGLE_CLIENT_SECRET"],
+  NEXT_PUBLIC_FD_FACEBOOK_CLIENT_ID: process.env["NEXT_PUBLIC_FD_FACEBOOK_CLIENT_ID"],
+  NEXT_PUBLIC_FD_FACEBOOK_CLIENT_SECRET: process.env["NEXT_PUBLIC_FD_FACEBOOK_CLIENT_SECRET"],
+  NEXT_PUBLIC_FD_MICROSOFT_CLIENT_ID: process.env["NEXT_PUBLIC_FD_MICROSOFT_CLIENT_ID"],
+  NEXT_PUBLIC_FD_MICROSOFT_CLIENT_SECRET: process.env["NEXT_PUBLIC_FD_MICROSOFT_CLIENT_SECRET"]
+};
+function valueToBooleanOrUndefined(value) {
+  return value?.trim().toLowerCase() === stringValueRepresentations.booleanTrue || void 0;
+}
+__name$k(valueToBooleanOrUndefined, "valueToBooleanOrUndefined");
+function optionalBooleanWithDefault(defaultValue) {
+  return z.string().optional().transform(valueToBooleanOrUndefined).pipe(z.boolean().default(defaultValue));
+}
+__name$k(optionalBooleanWithDefault, "optionalBooleanWithDefault");
+
+var __defProp$j = Object.defineProperty;
+var __name$j = (target, value) => __defProp$j(target, "name", { value, configurable: true });
+let envInstance;
+function getEnvInstance() {
+  if (!envInstance) {
+    envInstance = createEnvInstance();
+  }
+  return envInstance;
+}
+__name$j(getEnvInstance, "getEnvInstance");
+function createEnvInstance() {
+  return createEnv({
+    server: serverEnvSchema.shape,
+    client: clientEnvSchema.shape,
+    experimental__runtimeEnv: runtimeEnvSchema
+  });
+}
+__name$j(createEnvInstance, "createEnvInstance");
+
+var __defProp$i = Object.defineProperty;
+var __name$i = (target, value) => __defProp$i(target, "name", { value, configurable: true });
+getDotenvConfig();
+function getStringEnvSetting(setting) {
+  return getEnvSetting(setting, (value) => {
+    if (!isString(value)) {
+      throw createError(createEnvTypeErrorMessage(setting, envSettingTypes.string));
+    }
+    return value;
+  });
+}
+__name$i(getStringEnvSetting, "getStringEnvSetting");
+function getRequiredStringEnvSetting(setting) {
+  const value = getStringEnvSetting(setting);
+  if (value === null) {
+    throw createError(`Required environment setting ${setting} is not present in the .env file`);
+  }
+  return value;
+}
+__name$i(getRequiredStringEnvSetting, "getRequiredStringEnvSetting");
+function getNumberEnvSetting(setting) {
+  return getEnvSetting(setting, (value) => {
+    if (!isNumber(value)) {
+      throw createError(createEnvTypeErrorMessage(setting, envSettingTypes.number));
+    }
+    return value;
+  });
+}
+__name$i(getNumberEnvSetting, "getNumberEnvSetting");
+function getBooleanEnvSetting(setting) {
+  const envValue = getEnvSetting(setting, (value) => {
+    if (!isBoolean(value)) {
+      throw createError(createEnvTypeErrorMessage(setting, envSettingTypes.boolean));
+    }
+    return value;
+  });
+  return envValue ?? false;
+}
+__name$i(getBooleanEnvSetting, "getBooleanEnvSetting");
+function getEnvSetting(setting, typeValidator) {
+  const env = getEnvInstance();
+  const envValue = env[setting];
+  if (envValue === void 0) return null;
+  try {
+    return typeValidator(envValue);
+  } catch (error) {
+    error instanceof Error && handleGlobalError(error.message);
+    return null;
+  }
+}
+__name$i(getEnvSetting, "getEnvSetting");
+function createEnvTypeErrorMessage(setting, type) {
+  return `Environment setting ${setting} is not a ${type}`;
+}
+__name$i(createEnvTypeErrorMessage, "createEnvTypeErrorMessage");
+
+var __defProp$h = Object.defineProperty;
+var __name$h = (target, value) => __defProp$h(target, "name", { value, configurable: true });
+function isProd() {
+  return getAppEnvironment() === appEnvironments.production;
+}
+__name$h(isProd, "isProd");
+function isDev() {
+  return getAppEnvironment() === appEnvironments.development;
+}
+__name$h(isDev, "isDev");
+function isTest() {
+  return getAppEnvironment() === appEnvironments.test;
+}
+__name$h(isTest, "isTest");
+function isDemo() {
+  return getAppEnvironment() === appEnvironments.demo;
+}
+__name$h(isDemo, "isDemo");
+function isWebUiTest() {
+  return getBooleanEnvSetting(toolboxEnvSettingKeys.isWebUiTest);
+}
+__name$h(isWebUiTest, "isWebUiTest");
+function isWebSocketDisabled() {
+  return getBooleanEnvSetting(toolboxEnvSettingKeys.disableWebSockets);
+}
+__name$h(isWebSocketDisabled, "isWebSocketDisabled");
+function isAppEnvironmentKey(key) {
+  return isString(key) && Object.hasOwn(appEnvironments, key);
+}
+__name$h(isAppEnvironmentKey, "isAppEnvironmentKey");
+function getAppEnvironment() {
+  const env = process.env[toolboxEnvSettingKeys.appEnv];
+  if (isAppEnvironmentKey(env)) {
+    return appEnvironments[env];
+  }
+  return appEnvironments.development;
+}
+__name$h(getAppEnvironment, "getAppEnvironment");
+function isCi() {
+  return getBooleanEnvSetting(toolboxEnvSettingKeys.ci);
+}
+__name$h(isCi, "isCi");
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+__name$h(isBrowser, "isBrowser");
+function isPackageNodeMode() {
+  if (!isBrowser()) {
+    const mainFile = fileURLToPath(import.meta.url);
+    return mainFile.includes(`/${folders.nodeModules}/`);
+  }
+  return false;
+}
+__name$h(isPackageNodeMode, "isPackageNodeMode");
+function isPackageMode() {
+  return getRequiredStringEnvSetting(toolboxEnvSettingKeys.launchMode) !== launchMode.direct;
+}
+__name$h(isPackageMode, "isPackageMode");
+function isUsingS3() {
+  return getBooleanEnvSetting(toolboxEnvSettingKeys.useS3Compatible);
+}
+__name$h(isUsingS3, "isUsingS3");
+
+const httpMethods = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  delete: "DELETE"};
+
+const errorStatuses = {
+  400: {
+    title: "Bad Request",
+    description: "The server could not understand the request due to invalid syntax."
+  },
+  401: {
+    title: "Unauthorized",
+    description: "The client must authenticate itself to get the requested response."
+  },
+  402: {
+    title: "Payment Required",
+    description: "This status code is reserved for future use."
+  },
+  403: {
+    title: "Forbidden",
+    description: "The client does not have access rights to the content."
+  },
+  404: {
+    title: "Resource Not Found",
+    description: "The server can not find the requested resource."
+  },
+  405: {
+    title: "Method Not Allowed",
+    description: "The request method is known by the server but is not supported by the target resource."
+  },
+  406: {
+    title: "Not Acceptable",
+    description: "The server can only generate a response that is not acceptable according to the Accept headers sent in the request."
+  },
+  407: {
+    title: "Proxy Authentication Required",
+    description: "The client must first authenticate itself with the proxy."
+  },
+  408: {
+    title: "Request Timeout",
+    description: "The server did not receive a complete request from the client in time."
+  },
+  409: {
+    title: "Conflict",
+    description: "The request could not be completed due to a conflict with the current state of the target resource."
+  },
+  410: {
+    title: "Gone",
+    description: "The requested resource is no longer available and will not be available again."
+  },
+  411: {
+    title: "Length Required",
+    description: "The server refuses to accept the request without a defined Content-Length header."
+  },
+  412: {
+    title: "Precondition Failed",
+    description: "The server does not meet one of the preconditions that the requester put on the request."
+  },
+  413: {
+    title: "Payload Too Large",
+    description: "The request is larger than the server is willing or able to process."
+  },
+  414: {
+    title: "URI Too Long",
+    description: "The URI provided was too long for the server to process."
+  },
+  415: {
+    title: "Unsupported Media Type",
+    description: "The media type of the request is not supported by the server."
+  },
+  416: {
+    title: "Range Not Satisfiable",
+    description: "The client has asked for a portion of the file that the server cannot supply."
+  },
+  417: {
+    title: "Expectation Failed",
+    description: "The server cannot meet the requirements of the Expect request header field."
+  },
+  418: {
+    title: "I'm a teapot",
+    description: "Any attempt to instruct the teapot to brew coffee should result in the error code 418 I'm a teapot."
+  },
+  421: {
+    title: "Misdirected Request",
+    description: "The request was directed at a server that is not able to produce a response."
+  },
+  422: {
+    title: "Unprocessable Entity",
+    description: "The server understands the content type of the request entity, but was unable to process the contained instructions."
+  },
+  423: {
+    title: "Locked",
+    description: "The resource that is being accessed is locked."
+  },
+  424: {
+    title: "Failed Dependency",
+    description: "The request failed due to failure of a previous request."
+  },
+  425: {
+    title: "Too Early",
+    description: "Indicates that the server is unwilling to risk processing a request that might be replayed."
+  },
+  426: {
+    title: "Upgrade Required",
+    description: "The client should switch to a different protocol."
+  },
+  428: {
+    title: "Precondition Required",
+    description: "The origin server requires the request to be conditional."
+  },
+  429: {
+    title: "Too Many Requests",
+    description: "The user has sent too many requests in a given amount of time."
+  },
+  431: {
+    title: "Request Header Fields Too Large",
+    description: "The server is unwilling to process the request because its header fields are too large."
+  },
+  451: {
+    title: "Unavailable For Legal Reasons",
+    description: "The server is refusing to respond to the request due to legal reasons."
+  },
+  500: {
+    title: "Internal Server Error",
+    description: "The server has encountered a situation it does not know how to handle."
+  },
+  501: {
+    title: "Not Implemented",
+    description: "The request method is not supported by the server and cannot be handled."
+  },
+  502: {
+    title: "Bad Gateway",
+    description: "The server, while acting as a gateway or proxy, received an invalid response from the upstream server."
+  },
+  503: {
+    title: "Service Unavailable",
+    description: "The server is not ready to handle the request, typically due to overloading or maintenance."
+  },
+  504: {
+    title: "Gateway Timeout",
+    description: "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server."
+  },
+  505: {
+    title: "HTTP Version Not Supported",
+    description: "The server does not support the HTTP protocol version that was used in the request."
+  },
+  506: {
+    title: "Variant Also Negotiates",
+    description: "Transparent content negotiation for the request results in a circular reference."
+  },
+  507: {
+    title: "Insufficient Storage",
+    description: "The server is unable to store the representation needed to complete the request."
+  },
+  508: {
+    title: "Loop Detected",
+    description: "The server detected an infinite loop while processing a request."
+  },
+  510: {
+    title: "Not Extended",
+    description: "Further extensions to the request are required for the server to fulfill it."
+  },
+  511: {
+    title: "Network Authentication Required",
+    description: "The client needs to authenticate to gain network access."
+  }
+};
+
+var __defProp$g = Object.defineProperty;
+var __name$g = (target, value) => __defProp$g(target, "name", { value, configurable: true });
+function getProblemDetails(error, response, errorDescription = "", errorTitle = "Unknown Error") {
+  const problemDetails = {
+    title: errorStatuses[error.status]?.title || errorTitle,
+    status: error.status,
+    detail: errorDescription || error.message || errorStatuses[error.status]?.description,
+    instance: response.originalUrl
+  };
+  return problemDetails;
+}
+__name$g(getProblemDetails, "getProblemDetails");
+
+const httpStatusCodes = {
+  noContent: 204,
+  unauthorized: 401};
+
+const urlPathSeparator = "/";
+
+var __defProp$f = Object.defineProperty;
+var __name$f = (target, value) => __defProp$f(target, "name", { value, configurable: true });
+function combineEndpointPath(firstPathPart, secondPathPart) {
+  return firstPathPart + urlPathSeparator + secondPathPart;
+}
+__name$f(combineEndpointPath, "combineEndpointPath");
+function formatBlobName(name) {
+  return name.replaceAll("%2F", "/").replaceAll("\\", "/").replaceAll("%5C", "/");
+}
+__name$f(formatBlobName, "formatBlobName");
+
+const routes = {
+  root: "/",
+  login: "sign-in"};
+
+var __defProp$e = Object.defineProperty;
+var __name$e = (target, value) => __defProp$e(target, "name", { value, configurable: true });
+function getRelativeLoginUrl() {
+  return `/${routes.login}`;
+}
+__name$e(getRelativeLoginUrl, "getRelativeLoginUrl");
+function getLoginUrl() {
+  return window.location.origin + getRelativeLoginUrl();
+}
+__name$e(getLoginUrl, "getLoginUrl");
+function goToLogin() {
+  window.location.href = getRelativeLoginUrl();
+}
+__name$e(goToLogin, "goToLogin");
+
+var __defProp$d = Object.defineProperty;
+var __name$d = (target, value) => __defProp$d(target, "name", { value, configurable: true });
+function localStorageGetString(key) {
+  if (isBrowser()) {
+    const item = localStorage.getItem(key);
+    return item ?? void 0;
+  }
+  return void 0;
+}
+__name$d(localStorageGetString, "localStorageGetString");
+function getLocalStorage(key) {
+  const item = localStorageGetString(key);
+  return item ? parseJson(item) : void 0;
+}
+__name$d(getLocalStorage, "getLocalStorage");
+function setLocalStorage(key, value) {
+  if (value === void 0) return;
+  localStorage.setItem(key, JSON.stringify(value));
+}
+__name$d(setLocalStorage, "setLocalStorage");
+function removeLocalStorage(key) {
+  localStorage.removeItem(key);
+}
+__name$d(removeLocalStorage, "removeLocalStorage");
+
+const extensions = {
+  webp: "webp",
+  png: "png"
+};
+
+var __defProp$c = Object.defineProperty;
+var __name$c = (target, value) => __defProp$c(target, "name", { value, configurable: true });
+function getFileNameWithExtension(name, extension) {
+  if (!extension.startsWith(".")) return `${name}.${extension}`;
+  return name + extension;
+}
+__name$c(getFileNameWithExtension, "getFileNameWithExtension");
+function getFullFilePath(fileNameWithoutExtension, extension, ...paths) {
+  const fullFileName = getFileNameWithExtension(fileNameWithoutExtension, extension);
+  return join(...paths, fullFileName);
+}
+__name$c(getFullFilePath, "getFullFilePath");
+
+const publicFolder = {
+  images: "images"};
+const publicImages = {
+  user: "images/users"};
+const defaultImage = "profile";
+getFullFilePath(
+  defaultImage,
+  extensions.png,
+  routes.root,
+  publicFolder.images
+);
+
+var __defProp$b = Object.defineProperty;
+var __name$b = (target, value) => __defProp$b(target, "name", { value, configurable: true });
+function sessionStorageGetAsString(key) {
+  if (isBrowser()) {
+    const item = sessionStorage.getItem(key);
+    return item ?? void 0;
+  }
+  return void 0;
+}
+__name$b(sessionStorageGetAsString, "sessionStorageGetAsString");
+function getSessionStorage(key) {
+  const item = sessionStorageGetAsString(key);
+  return item ? parseJson(item) : void 0;
+}
+__name$b(getSessionStorage, "getSessionStorage");
+function setSessionStorage(key, value) {
+  if (value === void 0) return;
+  sessionStorage.setItem(key, JSON.stringify(value));
+}
+__name$b(setSessionStorage, "setSessionStorage");
+function removeSessionStorage(key) {
+  sessionStorage.removeItem(key);
+}
+__name$b(removeSessionStorage, "removeSessionStorage");
+
+var __defProp$a = Object.defineProperty;
+var __name$a = (target, value) => __defProp$a(target, "name", { value, configurable: true });
+const loginStateKey = "LoginState";
+const afterLoginRedirectUrlKey = "AfterLoginRedirectUrl";
+function isLoggedIn() {
+  return getLoginState().loggedIn;
+}
+__name$a(isLoggedIn, "isLoggedIn");
+function setLoginState(loginState) {
+  setLocalStorage(loginStateKey, loginState);
+}
+__name$a(setLoginState, "setLoginState");
+function getLoginState() {
+  return getLocalStorage(loginStateKey) ?? getEmptyLoginState();
+}
+__name$a(getLoginState, "getLoginState");
+function removeLoginState() {
+  removeLocalStorage(loginStateKey);
+}
+__name$a(removeLoginState, "removeLoginState");
+function getAfterLoginRedirectUrl() {
+  return getSessionStorage(afterLoginRedirectUrlKey);
+}
+__name$a(getAfterLoginRedirectUrl, "getAfterLoginRedirectUrl");
+function setAfterLoginRedirectUrl() {
+  const afterLoginRedirectUrl = (window.location.pathname + window.location.search).slice(1);
+  setSessionStorage(afterLoginRedirectUrlKey, afterLoginRedirectUrl);
+}
+__name$a(setAfterLoginRedirectUrl, "setAfterLoginRedirectUrl");
+function removeAfterLoginRedirectUrl() {
+  removeSessionStorage(afterLoginRedirectUrlKey);
+}
+__name$a(removeAfterLoginRedirectUrl, "removeAfterLoginRedirectUrl");
+function getEmptyLoginState() {
+  const emptyLoginState = {
+    email: "",
+    loggedIn: false,
+    displayName: "",
+    userId: emptyGuid,
+    imageUrl: `/${publicImages.user}/${emptyGuid}.${extensions.webp}`
+  };
+  return emptyLoginState;
+}
+__name$a(getEmptyLoginState, "getEmptyLoginState");
+
+var __defProp$9 = Object.defineProperty;
+var __name$9 = (target, value) => __defProp$9(target, "name", { value, configurable: true });
+async function apiBaseGet(url, headers) {
+  const response = await fetch(url, {
+    method: httpMethods.get,
+    headers
+  });
+  return baseApiHandleResponse(response);
+}
+__name$9(apiBaseGet, "apiBaseGet");
+async function apiBaseGetBlob(url, headers) {
+  const response = await fetch(url, {
+    method: httpMethods.get,
+    headers
+  });
+  return baseApiHandleBlobResponse(response);
+}
+__name$9(apiBaseGetBlob, "apiBaseGetBlob");
+async function postBaseApi(url, data, headers) {
+  const response = await fetch(url, {
+    method: httpMethods.post,
+    headers,
+    body: data instanceof URLSearchParams ? data : JSON.stringify(data)
+  });
+  return baseApiHandleResponse(response);
+}
+__name$9(postBaseApi, "postBaseApi");
+async function putBaseApi(url, data, headers) {
+  const response = await fetch(url, {
+    method: httpMethods.put,
+    headers,
+    body: JSON.stringify(data)
+  });
+  return baseApiHandleResponse(response);
+}
+__name$9(putBaseApi, "putBaseApi");
+async function deleteBaseApi(url, headers) {
+  const response = await fetch(url, {
+    method: httpMethods.delete,
+    headers
+  });
+  if (!response.ok) handleErrorResponse(response);
+}
+__name$9(deleteBaseApi, "deleteBaseApi");
+async function baseApiHandleResponse(response) {
+  const contentType = response.headers.get("content-type");
+  const includesJson = contentType?.includes("application/json");
+  if (isUnauthorizedError(response.status)) {
+    removeLoginState();
+    goToLogin();
+  }
+  if (!response.ok) {
+    const error = await handleErrorResponse(response);
+    return error;
+  }
+  if (response.status === httpStatusCodes.noContent || !includesJson) return null;
+  return getJsonFromResponse(response);
+}
+__name$9(baseApiHandleResponse, "baseApiHandleResponse");
+async function baseApiHandleBlobResponse(response) {
+  if (isUnauthorizedError(response.status)) {
+    goToLogin();
+  }
+  if (!response.ok) {
+    const error = await handleErrorResponse(response);
+    return error;
+  }
+  if (response.status === httpStatusCodes.noContent) {
+    return null;
+  }
+  const result = await response.blob();
+  return result;
+}
+__name$9(baseApiHandleBlobResponse, "baseApiHandleBlobResponse");
+async function handleErrorResponse(response) {
+  const contentType = response.headers.get("content-type");
+  const includesJson = contentType?.includes("application/json");
+  let errorMessage = "";
+  let errorDescription = "";
+  if (includesJson) {
+    const errorData = await getJsonFromResponse(response);
+    errorMessage = errorData?.message;
+    errorDescription = errorData?.description || "";
+  }
+  errorMessage = errorMessage ? errorMessage : response.statusText;
+  const errorDetails = { status: response.status, message: errorMessage };
+  const responseDetails = { originalUrl: response.url };
+  if (response.status !== httpStatusCodes.unauthorized) {
+    logAndNotify(new Error(errorMessage));
+  }
+  return getProblemDetails(errorDetails, responseDetails, errorDescription);
+}
+__name$9(handleErrorResponse, "handleErrorResponse");
+function isUnauthorizedError(status) {
+  return status === httpStatusCodes.unauthorized && isBrowser() && window.location.pathname !== getRelativeLoginUrl();
+}
+__name$9(isUnauthorizedError, "isUnauthorizedError");
+
+var __defProp$8 = Object.defineProperty;
+var __name$8 = (target, value) => __defProp$8(target, "name", { value, configurable: true });
+function addQueryParamsToPath(path, queryParams) {
+  let newPath = path;
+  if (queryParams && Array.isArray(queryParams)) {
+    newPath += convertQueryParamsArrayToString(queryParams);
+  } else if (queryParams && isPlainObject(queryParams)) {
+    newPath += convertQueryParamsObjectToString(queryParams);
+  }
+  return newPath;
+}
+__name$8(addQueryParamsToPath, "addQueryParamsToPath");
+function convertQueryParamsArrayToString(queryParams) {
+  const params = queryParams.map((param) => `${param.name}=${param.value}`).join("&");
+  return params ? `?${params}` : "";
+}
+__name$8(convertQueryParamsArrayToString, "convertQueryParamsArrayToString");
+function convertQueryParamsObjectToString(queryParams) {
+  const params = Object.entries(queryParams).map(([key, value]) => `${key}=${value}`).join("&");
+  return params ? `?${params}` : "";
+}
+__name$8(convertQueryParamsObjectToString, "convertQueryParamsObjectToString");
+
+var __defProp$7 = Object.defineProperty;
+var __name$7 = (target, value) => __defProp$7(target, "name", { value, configurable: true });
+const apiPrefix = "api";
+function getApiPath(endPoint, id, queryParams) {
+  let path = combineEndpointPath(apiPrefix, endPoint);
+  if (id) {
+    path = combineEndpointPath(path, id);
+  }
+  path = addQueryParamsToPath(path, queryParams);
+  return new URL(path, getBaseUrl()).href;
+}
+__name$7(getApiPath, "getApiPath");
+function getBaseUrl() {
+  return `${location.protocol}//${location.hostname}:${location.port}/`;
+}
+__name$7(getBaseUrl, "getBaseUrl");
+
+const oDataOperators = {
+  equal: "eq",
+  in: "in",
+  nin: "nin",
+  startsWith: "startswith",
+  empty: "none"
+};
+const oDataOrderByDirectionConsts = {
+  desc: 1
+};
+
+const shortTextLength = 200;
+const ellipsis = "\u2026";
+
+var __defProp$6 = Object.defineProperty;
+var __name$6 = (target, value) => __defProp$6(target, "name", { value, configurable: true });
+function shortenWithEllipsis(text, maxLength = shortTextLength) {
+  if (isNullOrUndefined(text)) {
+    return "";
+  }
+  if (text.length < 2) {
+    return text.length <= maxLength ? text : text.substring(0, maxLength);
+  } else {
+    return text.length <= maxLength ? text : text.substring(0, maxLength - 1) + ellipsis;
+  }
+}
+__name$6(shortenWithEllipsis, "shortenWithEllipsis");
+function trimCharacter(value, character) {
+  let result = value;
+  if (Array.isArray(character)) {
+    for (let ch of character) {
+      if (value.startsWith(ch) || value.endsWith(ch)) {
+        result = trimOneCharacter(value, ch);
+      }
+    }
+  } else {
+    result = trimOneCharacter(value, character);
+  }
+  return result;
+}
+__name$6(trimCharacter, "trimCharacter");
+function trimOneCharacter(value, character) {
+  let result = value;
+  if (result?.startsWith(character)) {
+    result = result.substring(1);
+  }
+  if (result?.endsWith(character)) {
+    result = result.substring(0, result.lastIndexOf(character));
+  }
+  return result;
+}
+__name$6(trimOneCharacter, "trimOneCharacter");
+
+const oDataNullValue = "null";
+
+const oDataFilterTypes = {
+  default: 0,
+  number: 1,
+  string: 2,
+  guid: 3,
+  lambda: 4,
+  date: 5
+};
+const oDataLogicalOperationTypes = {
+  or: 1
+};
+
+var __defProp$5 = Object.defineProperty;
+var __name$5 = (target, value) => __defProp$5(target, "name", { value, configurable: true });
+function getODataFilterAsString(filter) {
+  filter.operator ??= oDataOperators.equal;
+  if (filter.type === void 0 || filter.type === oDataFilterTypes.default) {
+    if (typeof filter.rightSide === "number") {
+      filter.type = oDataFilterTypes.number;
+    } else if (typeof filter.rightSide === "boolean" || typeof filter.rightSide === "string") {
+      filter.type = oDataFilterTypes.string;
+    } else if (filter.rightSide instanceof Date) {
+      filter.type = oDataFilterTypes.date;
+    } else {
+      filter.type = oDataFilterTypes.string;
+    }
+  }
+  if (typeof filter.rightSide === "string" && !isNaN(Number(filter.rightSide))) {
+    filter.rightSide = Number(filter.rightSide);
+  }
+  return getFilterString(filter);
+}
+__name$5(getODataFilterAsString, "getODataFilterAsString");
+function getFilterString(filter) {
+  switch (filter.operator) {
+    case oDataOperators.in:
+      return handleInOperator(filter);
+    case oDataOperators.nin:
+      return handleInOperator(filter);
+    case oDataOperators.empty:
+      return "";
+    case oDataOperators.startsWith:
+      return handleStartsWithOperator(filter);
+    default:
+      return handleDefaultOperators(filter);
+  }
+}
+__name$5(getFilterString, "getFilterString");
+function handleInOperator(filter) {
+  if (filter.type === oDataFilterTypes.guid) {
+    let rightHands = oDataFormatGuid(filter.rightSide);
+    return `${filter.leftSide} ${filter.operator} (${rightHands})`;
+  }
+  return `${filter.leftSide} ${filter.operator} (${filter.rightSide})`;
+}
+__name$5(handleInOperator, "handleInOperator");
+function handleStartsWithOperator(filter) {
+  return `${filter.operator}(${filter.leftSide}, ${filter.rightSide})`;
+}
+__name$5(handleStartsWithOperator, "handleStartsWithOperator");
+function handleDefaultOperators(filter) {
+  switch (filter.type) {
+    case oDataFilterTypes.string:
+      return handleStringFilter(filter);
+    case oDataFilterTypes.date:
+      return handleDateFilter(filter);
+    case oDataFilterTypes.guid:
+      return handleGuidFilter(filter);
+    case oDataFilterTypes.number:
+      return handleNumberFilter(filter);
+    case oDataFilterTypes.lambda:
+      return handleLambdaFilter(filter);
+    default:
+      throw createError(`Unsupported filter type: ${filter.type}`);
+  }
+}
+__name$5(handleDefaultOperators, "handleDefaultOperators");
+function handleStringFilter(filter) {
+  if (filter.rightSide === oDataNullValue) {
+    return `${filter.leftSide} ${filter.operator} ${filter.rightSide}`;
+  }
+  if (typeof filter.rightSide === "string") {
+    return `${filter.leftSide} ${filter.operator} '${filter.rightSide}'`;
+  }
+  return `${filter.leftSide} ${filter.operator} ${filter.rightSide}`;
+}
+__name$5(handleStringFilter, "handleStringFilter");
+function handleDateFilter(filter) {
+  return `${filter.leftSide} ${filter.operator} datetime'${filter.rightSide}'`;
+}
+__name$5(handleDateFilter, "handleDateFilter");
+function handleGuidFilter(filter) {
+  return `${filter.leftSide} ${filter.operator} guid'${filter.rightSide}'`;
+}
+__name$5(handleGuidFilter, "handleGuidFilter");
+function handleNumberFilter(filter) {
+  return `${filter.leftSide} ${filter.operator} ${filter.rightSide}`;
+}
+__name$5(handleNumberFilter, "handleNumberFilter");
+function handleLambdaFilter(filter) {
+  const lambdaConfig = filter.lambdaConfig;
+  if (!lambdaConfig) {
+    throw createError("Lambda configuration is missing");
+  }
+  return `${lambdaConfig.baseEnumerablePropertyName}/${lambdaConfig.method}(i:i/${filter.leftSide} ${filter.operator} guid'${filter.rightSide}')`;
+}
+__name$5(handleLambdaFilter, "handleLambdaFilter");
+function oDataFormatGuid(rightHand) {
+  let result;
+  if (typeof rightHand === "string") {
+    result = `${rightHand}`;
+  } else if (Array.isArray(rightHand)) {
+    result = rightHand.map((item) => `guid'${item}'`).join(",");
+  }
+  return result;
+}
+__name$5(oDataFormatGuid, "oDataFormatGuid");
+
+var __defProp$4 = Object.defineProperty;
+var __name$4 = (target, value) => __defProp$4(target, "name", { value, configurable: true });
+function getODataParams(oDataConfig) {
+  let oDataParams = getFilters(oDataConfig);
+  if (oDataConfig.skip) {
+    oDataParams.push({ name: "skip", value: oDataConfig.skip.toString() });
+  }
+  if (oDataConfig.top) {
+    oDataParams.push({ name: "top", value: oDataConfig.top.toString() });
+  }
+  if (oDataConfig.count) {
+    oDataParams.push({ name: "count", value: "true" });
+  }
+  if (oDataConfig.orderBys && oDataConfig.orderBys.length > 0) {
+    oDataConfig.orderBys.forEach((orderBy) => {
+      oDataParams.push({
+        name: "orderby",
+        value: getColumnNameAndDirectionForOrderBy(orderBy.propertyName, orderBy.direction)
+      });
+    });
+  }
+  if (oDataConfig.selects?.length || oDataConfig.select?.length) {
+    configureSelectOData(oDataConfig, oDataParams);
+  } else if (oDataConfig.expands) {
+    configureExpandOData(oDataConfig, oDataParams);
+  }
+  return oDataParams;
+}
+__name$4(getODataParams, "getODataParams");
+function getFilters(oDataConfig) {
+  let params = [];
+  if (oDataConfig.filters && oDataConfig.filters.length > 0) {
+    let filterParam = { name: "filter", value: "" };
+    let filterCount = oDataConfig.filters.length;
+    for (let i = 0; i < filterCount; i++) {
+      let filter = getODataFilterAsString(oDataConfig.filters[i]);
+      if (i > 0) {
+        if (oDataConfig.filters[i].logicalOperationType === oDataLogicalOperationTypes.or) {
+          filterParam.value += ` or ${filter}`;
+        } else {
+          filterParam.value += ` and ${filter}`;
+        }
+      } else {
+        filterParam.value += filter;
+      }
+    }
+    params.push(filterParam);
+  }
+  return params;
+}
+__name$4(getFilters, "getFilters");
+function getColumnNameAndDirectionForOrderBy(columnName, direction) {
+  return `${columnName} ${direction === oDataOrderByDirectionConsts.desc ? "desc" : "asc"}`;
+}
+__name$4(getColumnNameAndDirectionForOrderBy, "getColumnNameAndDirectionForOrderBy");
+function configureExpandOData(oDataConfig, oDataParams) {
+  if (oDataConfig.expands && oDataConfig.expands.length > 0) {
+    let resultValue = "";
+    for (let val of oDataConfig.expands) {
+      resultValue += `${val},`;
+    }
+    resultValue = trimCharacter(resultValue, ",");
+    oDataParams.push({ name: "expand", value: resultValue });
+  }
+}
+__name$4(configureExpandOData, "configureExpandOData");
+function configureSelectOData(oDataConfig, oDataParams) {
+  if (oDataConfig.select && oDataConfig.select.length > 0) {
+    let resultValue = "";
+    for (let val of oDataConfig.select) {
+      resultValue += `${val},`;
+    }
+    resultValue = trimCharacter(resultValue, ",");
+    oDataParams.push({ name: "select", value: resultValue });
+  }
+}
+__name$4(configureSelectOData, "configureSelectOData");
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+const tokenKey = "token";
+function getAuthToken() {
+  return getLocalStorage(tokenKey);
+}
+__name$3(getAuthToken, "getAuthToken");
+function rememberAuthToken(token) {
+  setLocalStorage(tokenKey, token);
+}
+__name$3(rememberAuthToken, "rememberAuthToken");
+function forgetAuthToken() {
+  removeLocalStorage(tokenKey);
+}
+__name$3(forgetAuthToken, "forgetAuthToken");
+
+const headerNames = {
+  authHeaderName: "authorization",
+  authHeaderValuePrefix: "Bearer "};
+const httpContentTypes = {
+  contentTypeHeaderName: "content-type",
+  contentTypeHeaderValue: "application/json"};
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+async function apiGet(endpoint, id, queryParams, headers) {
+  const url = getApiPath(endpoint, id, queryParams);
+  return apiBaseGet(url, getApiHeaders(headers));
+}
+__name$2(apiGet, "apiGet");
+async function apiGetBlob(endpoint, id, queryParams, headers) {
+  const url = getApiPath(endpoint, id, queryParams);
+  return apiBaseGetBlob(url, getApiHeaders(headers, true));
+}
+__name$2(apiGetBlob, "apiGetBlob");
+async function apiGetWithOData(endpoint, oDataConfig, id) {
+  const params = getODataParams(oDataConfig);
+  return apiGet(endpoint, id, params);
+}
+__name$2(apiGetWithOData, "apiGetWithOData");
+async function apiPost(endpoint, data, headers) {
+  const url = getApiPath(endpoint);
+  return postBaseApi(url, data, getApiHeaders(headers));
+}
+__name$2(apiPost, "apiPost");
+async function apiPostFile(endpoint, data, headers) {
+  const url = getApiPath(endpoint);
+  const response = await fetch(url, {
+    method: httpMethods.post,
+    body: data,
+    headers: getApiHeaders(headers, true)
+  });
+  return baseApiHandleResponse(response);
+}
+__name$2(apiPostFile, "apiPostFile");
+async function apiPut(endpoint, data, headers) {
+  const url = getApiPath(endpoint);
+  return putBaseApi(url, data, getApiHeaders(headers));
+}
+__name$2(apiPut, "apiPut");
+async function apiDelete(endpoint, id, headers) {
+  const url = getApiPath(endpoint, id);
+  return deleteBaseApi(url, getApiHeaders(headers));
+}
+__name$2(apiDelete, "apiDelete");
+function getApiHeaders(headers, skipContentType = false) {
+  const newHeaders = headers ?? new Headers();
+  const token = getAuthToken();
+  if ((!newHeaders.get(headerNames.authHeaderName) || newHeaders.get(headerNames.authHeaderName) === "") && token) {
+    newHeaders.set(headerNames.authHeaderName, headerNames.authHeaderValuePrefix + token);
+  }
+  if (!skipContentType && !newHeaders.get(httpContentTypes.contentTypeHeaderName)) {
+    newHeaders.set(httpContentTypes.contentTypeHeaderName, httpContentTypes.contentTypeHeaderValue);
+  }
+  return newHeaders;
+}
+__name$2(getApiHeaders, "getApiHeaders");
+
+const logErrorsConstants = {
+  errorMessageAffix: "Error"
+};
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+function logErrorRaw(error) {
+  createAndPostLog(logSeverities.error, error.name, error.message);
+  console.error(error);
+}
+__name$1(logErrorRaw, "logErrorRaw");
+function logStringError(error, innerError) {
+  const message = innerError ? innerError.name : logErrorsConstants.errorMessageAffix;
+  const errorMessage = innerError ? `${error} ${innerError.message}` : error;
+  createAndPostLog(logSeverities.error, message, errorMessage);
+  console.error(error, innerError);
+}
+__name$1(logStringError, "logStringError");
+function logWarningRaw(message) {
+  createAndPostLog(logSeverities.warning, message);
+  console.warn(message);
+}
+__name$1(logWarningRaw, "logWarningRaw");
+function logInfoRaw(message) {
+  createAndPostLog(logSeverities.info, message);
+  console.info(message);
+}
+__name$1(logInfoRaw, "logInfoRaw");
+function logDebugRaw(message) {
+  createAndPostLog(logSeverities.debug, message);
+  console.debug(message);
+}
+__name$1(logDebugRaw, "logDebugRaw");
+function createAndPostLog(severity, message, errorMessage) {
+  let logDto = {
+    severity,
+    message,
+    errorMessage
+  };
+  postLog(logDto);
+}
+__name$1(createAndPostLog, "createAndPostLog");
+function postLog(logDto) {
+  if (isBrowser()) {
+    apiPost(apiPathNames.log, logDto);
+  }
+}
+__name$1(postLog, "postLog");
+
+const filesToCopy = ["", "git"];
+const rootFilesToCopy = [
+  ".gitignore",
+  ".gitlab-ci.yml",
+  "postcss.config.mjs",
+  "tsconfig.declaration.json",
+  "README.md",
+  ".husky",
+  "server.ts"
+];
+const appFilesToCopy = [
+  clientPaths.styles,
+  `${projectPaths.app}/favicon.ico`,
+  `${projectPaths.app}/globals.css`,
+  `${projectPaths.app}/layout.tsx`,
+  `${projectPaths.app}/page.tsx`
+];
+const apiRoutesToCopy = [
+  `${projectPaths.apiV1}/searchable-resources/route.ts`,
+  `${projectPaths.apiV1}/searchresult/route.ts`,
+  `${projectPaths.apiV1}/workspace/change/route.ts`,
+  `${projectPaths.apiV1}/visible-workspace/route.ts`,
+  `${projectPaths.apiV1}/userpermission/route.ts`,
+  `${projectPaths.apiV1}/user-feature/is-enabled/route.ts`,
+  `${projectPaths.apiV1}/uimetas/route.ts`,
+  `${projectPaths.apiV1}/uimeta/route.ts`,
+  `${projectPaths.apiV1}/subscription/update/route.ts`,
+  `${projectPaths.apiV1}/subscription/create/route.ts`,
+  `${projectPaths.apiV1}/subscription/cancel/route.ts`,
+  `${projectPaths.apiV1}/sign-up/route.ts`,
+  `${projectPaths.apiV1}/sign-out/route.ts`,
+  `${projectPaths.apiV1}/sign-in/route.ts`,
+  `${projectPaths.apiV1}/preload/route.ts`,
+  `${projectPaths.apiV1}/payment/route.ts`,
+  `${projectPaths.apiV1}/payment/verify-success/route.ts`,
+  `${projectPaths.apiV1}/payment/verify-fail/route.ts`,
+  `${projectPaths.apiV1}/payment/method/route.ts`,
+  `${projectPaths.apiV1}/password/resetpassword/route.ts`,
+  `${projectPaths.apiV1}/password/forgotpassword/route.ts`,
+  `${projectPaths.apiV1}/otheruser/route.ts`,
+  `${projectPaths.apiV1}/otheruser/[id]/route.ts`,
+  `${projectPaths.apiV1}/log/route.ts`,
+  `${projectPaths.apiV1}/blob/[filename]/route.ts`,
+  `${projectPaths.apiV1}/[resourceName]/route.ts`,
+  `${projectPaths.apiV1}/[resourceName]/upsert/route.ts`,
+  `${projectPaths.apiV1}/[resourceName]/[id]/route.ts`
+];
+const allFilesToCopy = [
+  ...filesToCopy,
+  ...rootFilesToCopy,
+  ...appFilesToCopy,
+  ...apiRoutesToCopy
+];
+
+const npmPackages = {
+  saasKit: "@fernir2/saas-kit",
+  saasKitServer: "@fernir2/saas-kit/server"};
+
+const aliasSymbols = {
+  atSign: "@"};
+const typescriptAliases = {
+  "@": "./src",
+  "@cli": "./packages/level2/cli",
+  "@server": "./packages/level2/server",
+  "@schemas": "./generated",
+  "@npm-commands": "./packages/level2/npm-commands",
+  "@root": ".",
+  "@enricher": "./packages/level2/enricher",
+  "@packages": "./packages",
+  "@common": "./packages/level2/common",
+  "@meta": "./packages/level2/meta",
+  "@fd-toolbox": "./packages/level2/fd-toolbox",
+  "@fd-toolbox-core": "./packages/level2/fd-toolbox-core",
+  "@fd-component-toolbox": "./packages/level2/fd-component-toolbox",
+  "@fd-app-toolbox": "./packages/level2/fd-app-toolbox",
+  "@client": "./packages/level2/client"
+};
+Object.fromEntries(
+  Object.entries(typescriptAliases).map(([key, value]) => [`${key}/*`, [`${value}/*`]])
+);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const requiredNodeVersion = "v18.0.0";
 if (process.version < requiredNodeVersion) {
-    logStringError(`Node.js ${requiredNodeVersion}+ is required`);
-    process.exit(1);
+  logStringError(`Node.js ${requiredNodeVersion}+ is required`);
+  process.exit(1);
 }
-const filename = fileURLToPath(import.meta.url);
+const filename = fileURLToPath$1(import.meta.url);
 const dir = path.dirname(filename);
 const repoRoot = path.resolve(dir, "..");
 const saasKitRoot = path.resolve(dir, "../../..");
@@ -26,237 +1532,251 @@ const envLocalPath = path.join(dir, `../${folders.cli}/.env`);
 const envTemplate = fs.readFileSync(envLocalPath, "utf8");
 const foldersToIgnore = [`${folders.cli}/constants`];
 function runCommand(command, cwd) {
-    logInfoRaw(`Executing: ${command}`);
-    try {
-        execSync(command, { stdio: "inherit", cwd: cwd ?? process.cwd() });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logStringError(`Error executing: ${command}`);
-        logStringError(errorMessage);
-        process.exit(1);
-    }
+  logInfoRaw(`Executing: ${command}`);
+  try {
+    execSync(command, { stdio: "inherit", cwd: cwd ?? process.cwd() });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logStringError(`Error executing: ${command}`);
+    logStringError(errorMessage);
+    process.exit(1);
+  }
 }
+__name(runCommand, "runCommand");
 function checkTargetFolder(targetDir) {
-    if (existsSync(targetDir)) {
-        logStringError(`Error: Folder "${path.basename(targetDir)}" already exists.`);
-        process.exit(1);
-    }
+  if (existsSync(targetDir)) {
+    logStringError(`Error: Folder "${path.basename(targetDir)}" already exists.`);
+    process.exit(1);
+  }
 }
+__name(checkTargetFolder, "checkTargetFolder");
 function getCreateNextAppVersion() {
-    const packageJsonPath = path.resolve(saasKitRoot, "package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-    return String(packageJson.devDependencies?.["next"] ?? packageJson.dependencies?.["next"] ?? "latest");
+  const packageJsonPath = path.resolve(saasKitRoot, "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  return String(packageJson.devDependencies?.["next"] ?? packageJson.dependencies?.["next"] ?? "latest");
 }
+__name(getCreateNextAppVersion, "getCreateNextAppVersion");
 function createNextProject(projectTitle, targetDir) {
-    logInfoRaw("Creating Next.js project...");
-    const createNextAppVersion = getCreateNextAppVersion();
-    const createCommand = [
-        `npx create-next-app@${createNextAppVersion} "${projectTitle}"`,
-        "--typescript",
-        "--tailwind",
-        "--eslint",
-        "--app",
-        "--src-dir",
-        "--turbopack",
-        "--no-import-alias",
-        "--no-git",
-    ].join(" ");
-    runCommand(createCommand, path.dirname(targetDir));
-    logInfoRaw("Next.js project created!");
+  logInfoRaw("Creating Next.js project...");
+  const createNextAppVersion = getCreateNextAppVersion();
+  const createCommand = [
+    `npx create-next-app@${createNextAppVersion} "${projectTitle}"`,
+    "--typescript",
+    "--tailwind",
+    "--eslint",
+    "--app",
+    "--src-dir",
+    "--turbopack",
+    "--no-import-alias",
+    "--no-git"
+  ].join(" ");
+  runCommand(createCommand, path.dirname(targetDir));
+  logInfoRaw("Next.js project created!");
 }
+__name(createNextProject, "createNextProject");
 async function createEnvFile(targetDir) {
-    logInfoRaw("Creating .env file with default values...");
-    const envPath = path.join(targetDir, ".env");
-    try {
-        await fsPromises.writeFile(envPath, envTemplate, "utf8");
-        logInfoRaw(".env file created with values!");
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logStringError("Error creating .env file:");
-        logStringError(errorMessage);
-        throw error;
-    }
+  logInfoRaw("Creating .env file with default values...");
+  const envPath = path.join(targetDir, ".env");
+  try {
+    await promises.writeFile(envPath, envTemplate, "utf8");
+    logInfoRaw(".env file created with values!");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logStringError("Error creating .env file:");
+    logStringError(errorMessage);
+    throw error;
+  }
 }
+__name(createEnvFile, "createEnvFile");
 async function overridePackageJson(targetDir) {
-    const targetPackageJsonPath = path.join(targetDir, "package.json");
-    const cliPackageJsonPath = path.join(repoRoot, `${folders.cli}/package-template.json`);
-    try {
-        const targetPackageJson = JSON.parse(await fsPromises.readFile(targetPackageJsonPath, "utf8"));
-        const name = targetPackageJson.name;
-        const cliPackageJson = JSON.parse(await fsPromises.readFile(cliPackageJsonPath, "utf8"));
-        const finalPackageJson = {
-            ...cliPackageJson,
-            name: name,
-        };
-        await fsPromises.writeFile(targetPackageJsonPath, `${JSON.stringify(finalPackageJson, null, 2)}\n`, "utf8");
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logStringError("Error overriding package.json:");
-        logStringError(errorMessage);
-        throw error;
-    }
+  const targetPackageJsonPath = path.join(targetDir, "package.json");
+  const cliPackageJsonPath = path.join(repoRoot, `${folders.cli}/package-template.json`);
+  try {
+    const targetPackageJson = JSON.parse(
+      await promises.readFile(targetPackageJsonPath, "utf8")
+    );
+    const name = targetPackageJson.name;
+    const cliPackageJson = JSON.parse(await promises.readFile(cliPackageJsonPath, "utf8"));
+    const finalPackageJson = {
+      ...cliPackageJson,
+      name
+    };
+    await promises.writeFile(
+      targetPackageJsonPath,
+      `${JSON.stringify(finalPackageJson, null, 2)}
+`,
+      "utf8"
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logStringError("Error overriding package.json:");
+    logStringError(errorMessage);
+    throw error;
+  }
 }
+__name(overridePackageJson, "overridePackageJson");
 function replaceImports(content) {
-    const importRegex = /(import\s+[^'"]*from\s+["'])([^"']+)(["'])/g;
-    return content.replace(importRegex, (match, p1, importPath, p3) => {
-        if (!importPath.startsWith(aliasSymbols.atSign) || importPath.startsWith(npmPackages.saasKit)) {
-            return match;
-        }
-        if (importPath.startsWith(aliasSymbols.atSign + folders.server) ||
-            importPath.includes(`/${folders.server}/`)) {
-            return `${p1}${npmPackages.saasKitServer}${p3}`;
-        }
-        return `${p1}${npmPackages.saasKit}${p3}`;
-    });
+  const importRegex = /(import\s+[^'"]*from\s+["'])([^"']+)(["'])/g;
+  return content.replace(importRegex, (match, p1, importPath, p3) => {
+    if (!importPath.startsWith(aliasSymbols.atSign) || importPath.startsWith(npmPackages.saasKit)) {
+      return match;
+    }
+    if (importPath.startsWith(aliasSymbols.atSign + folders.server) || importPath.includes(`/${folders.server}/`)) {
+      return `${p1}${npmPackages.saasKitServer}${p3}`;
+    }
+    return `${p1}${npmPackages.saasKit}${p3}`;
+  });
 }
+__name(replaceImports, "replaceImports");
 async function copyProjectFiles(targetDir) {
-    logInfoRaw(`Copying ${projectName} files...`);
-    for (const file of allFilesToCopy) {
-        const cliFile = `${folders.cli}/${file}`;
-        const srcPath = path.join(repoRoot, cliFile);
-        const processedFile = replaceToolsFolder(file);
-        const destPath = path.join(targetDir, processedFile);
-        if (existsSync(srcPath)) {
-            const stats = await fsPromises.stat(srcPath);
-            if (stats.isDirectory()) {
-                await copyDirectoryContents(srcPath, destPath);
-            }
-            else {
-                await copyAndProcessFile(srcPath, destPath);
-            }
-        }
-        else {
-            logInfoRaw(`Source file not found: ${cliFile}`);
-        }
+  logInfoRaw(`Copying ${projectName} files...`);
+  for (const file of allFilesToCopy) {
+    const cliFile = `${folders.cli}/${file}`;
+    const srcPath = path.join(repoRoot, cliFile);
+    const processedFile = replaceToolsFolder(file);
+    const destPath = path.join(targetDir, processedFile);
+    if (existsSync(srcPath)) {
+      const stats = await promises.stat(srcPath);
+      if (stats.isDirectory()) {
+        await copyDirectoryContents(srcPath, destPath);
+      } else {
+        await copyAndProcessFile(srcPath, destPath);
+      }
+    } else {
+      logInfoRaw(`Source file not found: ${cliFile}`);
     }
-    logInfoRaw("Files copied and imports updated!");
+  }
+  logInfoRaw("Files copied and imports updated!");
 }
+__name(copyProjectFiles, "copyProjectFiles");
 function replaceToolsFolder(file) {
-    let processedFile = file;
-    for (const [folderPrefix, replacements] of Object.entries(toolsFoldersToReplace)) {
-        if (processedFile.startsWith(folderPrefix) && isWithIndexer(replacements)) {
-            const typedReplacements = replacements;
-            for (const key in typedReplacements) {
-                const value = typedReplacements[key];
-                if (isString(value)) {
-                    processedFile = processedFile.replace(key, value);
-                }
-            }
-            break;
+  let processedFile = file;
+  for (const [folderPrefix, replacements] of Object.entries(toolsFoldersToReplace)) {
+    if (processedFile.startsWith(folderPrefix) && isWithIndexer(replacements)) {
+      const typedReplacements = replacements;
+      for (const key in typedReplacements) {
+        const value = typedReplacements[key];
+        if (isString(value)) {
+          processedFile = processedFile.replace(key, value);
         }
+      }
+      break;
     }
-    return processedFile;
+  }
+  return processedFile;
 }
+__name(replaceToolsFolder, "replaceToolsFolder");
 function shouldIgnorePath(filePath, basePath, isDirectory = false) {
-    const relativePath = path.relative(basePath, filePath);
-    const pathParts = relativePath.split(path.sep);
-    const relativeFromRepo = path.relative(repoRoot, filePath).replace(/\\/g, "/");
-    return ((isDirectory && foldersToIgnore.includes(relativeFromRepo)) ||
-        foldersToIgnore.some((ignoreFolder) => pathParts.some((part) => part === ignoreFolder)));
+  const relativePath = path.relative(basePath, filePath);
+  const pathParts = relativePath.split(path.sep);
+  const relativeFromRepo = path.relative(repoRoot, filePath).replace(/\\/g, "/");
+  return isDirectory && foldersToIgnore.includes(relativeFromRepo) || foldersToIgnore.some((ignoreFolder) => pathParts.some((part) => part === ignoreFolder));
 }
+__name(shouldIgnorePath, "shouldIgnorePath");
 async function copyDirectoryContents(srcDir, destDir) {
-    if (!existsSync(destDir)) {
-        mkdirSync(destDir, { recursive: true });
-    }
-    try {
-        const entries = await fsPromises.readdir(srcDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const srcPath = path.join(srcDir, entry.name);
-            const destPath = path.join(destDir, entry.name);
-            if (!shouldIgnorePath(srcPath, srcDir, entry.isDirectory())) {
-                if (entry.isDirectory()) {
-                    await copyDirectoryContents(srcPath, destPath);
-                }
-                else {
-                    await copyAndProcessFile(srcPath, destPath);
-                }
-            }
+  if (!existsSync(destDir)) {
+    mkdirSync(destDir, { recursive: true });
+  }
+  try {
+    const entries = await promises.readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(srcDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (!shouldIgnorePath(srcPath, srcDir, entry.isDirectory())) {
+        if (entry.isDirectory()) {
+          await copyDirectoryContents(srcPath, destPath);
+        } else {
+          await copyAndProcessFile(srcPath, destPath);
         }
+      }
     }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logStringError(`Error reading directory ${srcDir}: ${errorMessage}`);
-        throw error;
-    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logStringError(`Error reading directory ${srcDir}: ${errorMessage}`);
+    throw error;
+  }
 }
+__name(copyDirectoryContents, "copyDirectoryContents");
 async function copyAndProcessFile(srcPath, destPath) {
-    const destDir = path.dirname(destPath);
-    if (!existsSync(destDir)) {
-        mkdirSync(destDir, { recursive: true });
-    }
-    const stats = await fsPromises.stat(srcPath);
-    if (stats.isDirectory()) {
-        await copyDirectoryContents(srcPath, destPath);
-    }
-    else {
-        const content = await fsPromises.readFile(srcPath, "utf8");
-        const processedContent = replaceImports(content);
-        await fsPromises.writeFile(destPath, processedContent, "utf8");
-    }
+  const destDir = path.dirname(destPath);
+  if (!existsSync(destDir)) {
+    mkdirSync(destDir, { recursive: true });
+  }
+  const stats = await promises.stat(srcPath);
+  if (stats.isDirectory()) {
+    await copyDirectoryContents(srcPath, destPath);
+  } else {
+    const content = await promises.readFile(srcPath, "utf8");
+    const processedContent = replaceImports(content);
+    await promises.writeFile(destPath, processedContent, "utf8");
+  }
 }
+__name(copyAndProcessFile, "copyAndProcessFile");
 function createAdditionalFolders(targetDir) {
-    for (const folder of additionalFoldersToCreate) {
-        const folderPath = path.join(targetDir, folder);
-        if (!existsSync(folderPath)) {
-            mkdirSync(folderPath, { recursive: true });
-            logInfoRaw(`Created folder: ${folder}`);
-        }
+  for (const folder of additionalFoldersToCreate) {
+    const folderPath = path.join(targetDir, folder);
+    if (!existsSync(folderPath)) {
+      mkdirSync(folderPath, { recursive: true });
+      logInfoRaw(`Created folder: ${folder}`);
     }
-    logInfoRaw("Additional folders created!");
+  }
+  logInfoRaw("Additional folders created!");
 }
+__name(createAdditionalFolders, "createAdditionalFolders");
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length < 1) {
-        logStringError("Error: Specify folder name. Example: npx create-saas-kit-app <folder-name>");
-        process.exit(1);
-    }
-    const folderName = args[0];
-    const targetDir = path.resolve(process.cwd(), folderName);
-    logInfoRaw(`\nCreating ${projectName} project "${folderName}"...\n`);
-    try {
-        checkTargetFolder(targetDir);
-        createNextProject(folderName, targetDir);
-        await copyProjectFiles(targetDir);
-        await overridePackageJson(targetDir);
-        createAdditionalFolders(targetDir);
-        await createEnvFile(targetDir);
-        await updateLayoutTitle(targetDir, folderName);
-        logInfoRaw(`\n${projectName} project "${folderName}" is ready!`);
-        logInfoRaw("Next steps:");
-        logInfoRaw(`  cd ${folderName}`);
-        logInfoRaw("  npm run prod");
-        logInfoRaw("  npm start");
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logStringError("Error:");
-        logStringError(errorMessage);
-        if (existsSync(targetDir)) {
-            logInfoRaw("Cleaning up...");
-            rmSync(targetDir, { recursive: true, force: true });
-        }
-        process.exit(1);
+  const args = process.argv.slice(2);
+  if (args.length < 1) {
+    logStringError("Error: Specify folder name. Example: npx create-saas-kit-app <folder-name>");
+    process.exit(1);
+  }
+  const folderName = args[0];
+  const targetDir = path.resolve(process.cwd(), folderName);
+  logInfoRaw(`
+Creating ${projectName} project "${folderName}"...
+`);
+  try {
+    checkTargetFolder(targetDir);
+    createNextProject(folderName, targetDir);
+    await copyProjectFiles(targetDir);
+    await overridePackageJson(targetDir);
+    createAdditionalFolders(targetDir);
+    await createEnvFile(targetDir);
+    await updateLayoutTitle(targetDir, folderName);
+    logInfoRaw(`
+${projectName} project "${folderName}" is ready!`);
+    logInfoRaw("Next steps:");
+    logInfoRaw(`  cd ${folderName}`);
+    logInfoRaw("  npm run prod");
+    logInfoRaw("  npm start");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logStringError("Error:");
+    logStringError(errorMessage);
+    if (existsSync(targetDir)) {
+      logInfoRaw("Cleaning up...");
+      rmSync(targetDir, { recursive: true, force: true });
     }
+    process.exit(1);
+  }
 }
+__name(main, "main");
 async function updateLayoutTitle(targetDir, folderName) {
-    const layoutPath = path.join(targetDir, "src/app/layout.tsx");
-    if (!existsSync(layoutPath)) {
-        throw createError(`layout.tsx not found at ${layoutPath}, cannot update title.`);
-    }
-    let content = await fsPromises.readFile(layoutPath, "utf8");
-    const titleRegex = /"SaaS Kit"/g;
-    if (!titleRegex.test(content)) {
-        throw createError("SaaS Kit not found in layout.tsx, cannot update title.");
-    }
-    content = content.replace(titleRegex, `"${folderName}"`);
-    await fsPromises.writeFile(layoutPath, content, "utf8");
+  const layoutPath = path.join(targetDir, "src/app/layout.tsx");
+  if (!existsSync(layoutPath)) {
+    throw createError(`layout.tsx not found at ${layoutPath}, cannot update title.`);
+  }
+  let content = await promises.readFile(layoutPath, "utf8");
+  const titleRegex = /"SaaS Kit"/g;
+  if (!titleRegex.test(content)) {
+    throw createError("SaaS Kit not found in layout.tsx, cannot update title.");
+  }
+  content = content.replace(titleRegex, `"${folderName}"`);
+  await promises.writeFile(layoutPath, content, "utf8");
 }
+__name(updateLayoutTitle, "updateLayoutTitle");
 main().catch((error) => {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    logStringError("Unhandled error:");
-    logStringError(errorMessage);
-    process.exit(1);
+  const errorMessage = error instanceof Error ? error.message : "Unknown error";
+  logStringError("Unhandled error:");
+  logStringError(errorMessage);
+  process.exit(1);
 });