@genesislcap/blank-app-seed 5.22.2-prerelease.2 → 5.23.1

package/client-tmp/react/.oxlintrc.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "extends": ["./node_modules/@genesislcap/oxlint-config/.oxlintrc.json"]
+}

package/client-tmp/react/README.md

@@ -27,7 +27,8 @@ Run `npm run test:e2e` to execute the end-to-end tests.
 
 ## Linting
 
-Run `npm run lint` to lint the project.
+Run `npm run lint` to lint the project (Oxlint → Oxfmt → Stylelint via `genx lint -l ox`).
+Run `npm run lint:fix` to auto-fix lint findings and formatting.
 
 ## Styling
 
@@ -52,9 +53,8 @@ modes, and the selected mode is remembered across reloads.
 - `npm run dev:no-open`: Serves the project in development mode without automatically opening the browser.
 - `npm run dev:intellij`: Serves the project in development mode (specific for IntelliJ).
 - `npm run dev:https`: Serves the project in development mode with HTTPS.
-- `npm run lint`: Lints the project using the specified profile.
-- `npm run lint:fix`: Fixes linting errors in the project.
-- `npm run lint:eslint`: Lints the project using ESLint and the specified profile.
+- `npm run lint`: Lints the project (Oxlint → Oxfmt → Stylelint).
+- `npm run lint:fix`: Fixes lint findings and formatting.
 - `npm run lint:stylelint`: Lints CSS using a custom script.
 - `npm run test`: Runs unit tests.
 - `npm run test:e2e`: Runs end-to-end tests.

package/client-tmp/react/jest.config.ts

@@ -4,12 +4,16 @@ const config: Config.InitialOptions = {
   testEnvironment: 'jsdom',
   moduleFileExtensions: ['js', 'jsx', 'ts', 'tsx'],
   transform: {
-    '^.+\\.jsx?$': 'babel-jest',
+    '^.+\\.jsx?$': ['babel-jest', { presets: ['@babel/preset-env'] }],
     '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.app.json' }],
   },
+  moduleNameMapper: {
+    '\\.(css|jpg|jpeg|png|gif|svg|woff2?)$': '<rootDir>/src/__mocks__/fileMock.js',
+  },
+  transformIgnorePatterns: ['node_modules/(?!(@genesislcap/*|consola|@microsoft|exenv-es6|uuid))'],
   setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
-  testMatch: ["**/?(*.)+(test).[jt]s?(x)"],
-  watchPathIgnorePatterns: ["<rootDir>/node_modules/", "<rootDir>/dist/"],
+  testMatch: ['**/?(*.)+(test).[jt]s?(x)'],
+  watchPathIgnorePatterns: ['<rootDir>/node_modules/', '<rootDir>/dist/'],
 };
 
-export default config;
+export default config;

package/client-tmp/react/jest.setup.ts

@@ -1 +1,85 @@
-import '@testing-library/jest-dom';
+import { TextDecoder, TextEncoder } from 'node:util';
+import '@testing-library/jest-dom';
+
+// jsdom does not provide TextEncoder/TextDecoder, which react-router needs at import time.
+if (typeof globalThis.TextEncoder === 'undefined') {
+  Object.assign(globalThis, { TextEncoder, TextDecoder });
+}
+
+// Mock window.matchMedia (fast-foundation reads it at import time)
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: (query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: jest.fn(), // Deprecated
+    removeListener: jest.fn(), // Deprecated
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn(),
+  }),
+});
+
+// Mock BroadcastChannel
+class MockBroadcastChannel {
+  name: string;
+  onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null = null;
+  onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null = null;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  postMessage(message: any) {
+    if (this.onmessage) {
+      this.onmessage({ data: message } as MessageEvent);
+    }
+  }
+
+  close() {}
+
+  addEventListener() {}
+  removeEventListener() {}
+  dispatchEvent() {
+    return false;
+  }
+}
+
+Object.defineProperty(window, 'BroadcastChannel', {
+  writable: true,
+  value: MockBroadcastChannel,
+});
+
+// jsdom lacks the constructable-stylesheet API used by the modal-theme runtime
+// (CSSStyleSheet.replaceSync + Document.adoptedStyleSheets)
+if (typeof CSSStyleSheet === 'undefined') {
+  Object.defineProperty(window, 'CSSStyleSheet', {
+    writable: true,
+    value: class {
+      replaceSync() {}
+    },
+  });
+} else if (!CSSStyleSheet.prototype.replaceSync) {
+  CSSStyleSheet.prototype.replaceSync = () => {};
+}
+
+if (!('adoptedStyleSheets' in document)) {
+  Object.defineProperty(document, 'adoptedStyleSheets', {
+    writable: true,
+    value: [],
+  });
+}
+
+// jsdom lacks structuredClone, which the design-system theme merge uses
+if (typeof globalThis.structuredClone === 'undefined') {
+  Object.defineProperty(globalThis, 'structuredClone', {
+    writable: true,
+    value: (value: unknown) => JSON.parse(JSON.stringify(value)),
+  });
+}
+
+// jsdom's sandbox does not expose Node's global fetch; foundation-auth references it at import time.
+if (typeof globalThis.fetch === 'undefined') {
+  Object.defineProperty(globalThis, 'fetch', { writable: true, value: jest.fn() });
+}

package/client-tmp/react/oxlint-staged.js

@@ -0,0 +1,45 @@
+/**
+ * Lints the staged files, fixing what can be fixed and failing on what cannot.
+ *
+ * `oxlint --fix` is not single-pass convergent: it applies at most one fix per
+ * overlapping span, so a file with several unused specifiers in one import
+ * statement still reports the rest afterwards. A single
+ * `oxlint --fix --deny-warnings` would therefore reject a commit whose findings
+ * are entirely auto-fixable, and lint-staged would revert the partial fix. There
+ * is no `--fix-passes` flag (oxlint 1.78), so the loop lives here; it can go
+ * back to one plain call once oxlint converges on its own.
+ *
+ * The fixing passes stay quiet so a remaining finding is reported once, by the
+ * final pass, rather than once per attempt.
+ */
+const { spawnSync } = require('node:child_process');
+
+/** Convergence needs about log2(findings) passes; this is well clear of that. */
+const MAX_PASSES = 10;
+
+const files = process.argv.slice(2);
+
+const runOxlint = (args, quiet) =>
+  spawnSync('oxlint', [...args, ...files], {
+    stdio: quiet ? 'ignore' : 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+if (files.length === 0) {
+  process.exit(0);
+}
+
+for (let pass = 0; pass < MAX_PASSES; pass += 1) {
+  const { status, error } = runOxlint(['--fix', '--deny-warnings'], true);
+  if (error) {
+    // Never fail silently: a missing binary must not look like a lint failure.
+    console.error(`oxlint-staged: could not run oxlint (${error.code})`);
+    process.exit(1);
+  }
+  if (status === 0) {
+    process.exit(0);
+  }
+}
+
+// Still not clean: report what is left (without touching the files again) and fail.
+process.exit(runOxlint(['--deny-warnings'], false).status === 0 ? 0 : 1);

package/client-tmp/react/package.json

@@ -28,11 +28,10 @@
     "dev:no-open": "NO_OPEN=true npm run dev",
     "dev:intellij": "npm run dev",
     "dev:https": "HTTPS=true npm run dev",
-    "lint": "genx lint --profile",
-    "lint:fix": "genx lint --fix",
-    "lint:eslint": "genx lint -l eslint --profile",
+    "git:setup": "cd .. && npx --no --prefix client husky install",
+    "lint": "genx lint -l ox",
+    "lint:fix": "genx lint -l ox --fix",
     "lint:stylelint": "genx lint -l stylelint",
-    "stats": "webpack --mode production --json > stats.json",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "test:unit:watch": "jest --watchAll",
@@ -40,7 +39,18 @@
     "test:e2e:debug": "genx test --e2e --debug",
     "test:e2e:ui": "genx test --e2e --interactive"
   },
-  "prettier": "@genesislcap/prettier-config",
+  "lint-staged": {
+    "*.{ts,js,tsx,jsx}": [
+      "node oxlint-staged.js",
+      "oxfmt --write"
+    ],
+    "*.{mjs,cjs}": [
+      "oxfmt --write"
+    ]
+  },
+  "stylelint": {
+    "extends": "@genesislcap/stylelint-config"
+  },
   "dependencies": {
     "@microsoft/fast-react-wrapper": ">=0.3.25",
     "ag-grid-community": "36.0.0",
@@ -60,6 +70,7 @@
     "@genesislcap/foundation-notifications": "{{versions.UI}}",
     "@genesislcap/foundation-react-utils": "{{versions.UI}}",
     "@genesislcap/foundation-shell": "{{versions.UI}}",
+    "@genesislcap/foundation-store": "{{versions.UI}}",
     "@genesislcap/foundation-ui": "{{versions.UI}}",
     "@genesislcap/foundation-user": "{{versions.UI}}",
     "@genesislcap/foundation-utils": "{{versions.UI}}",
@@ -91,13 +102,15 @@
     "@analytics/core": "0.12.17"
   },
   "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
     "@genesislcap/design-system-configurator": "{{versions.UI}}",
-    "@genesislcap/eslint-config": "{{versions.UI}}",
-    "@genesislcap/prettier-config": "{{versions.UI}}",
     "@genesislcap/foundation-testing": "{{versions.UI}}",
     "@genesislcap/genx": "{{versions.UI}}",
     "@genesislcap/event-type-codegen": "{{versions.UI}}",
     "@genesislcap/build-kit": "{{versions.UI}}",
+    "@genesislcap/oxlint-config": "{{versions.UI}}",
+    "@genesislcap/stylelint-config": "{{versions.UI}}",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "^6.5.0",
     "@testing-library/react": "^16.1.0",
@@ -106,10 +119,12 @@
     "@types/node": "^20.14.10",
     "@types/react": "^19.2.0",
     "@types/react-dom": "^19.2.0",
-    "eslint-plugin-react-hooks": "^5.1.0",
-    "eslint-plugin-react-refresh": "^0.4.16",
+    "husky": "^7.0.4",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
+    "lint-staged": "^12.4.1",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.77.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "typescript": "5.9.2"

package/client-tmp/react/playwright.config.ts

@@ -2,16 +2,17 @@ import { configDefaults } from '@genesislcap/foundation-testing/e2e';
 
 export const PROTOCOL = process.env['PROTOCOL'] || 'http';
 export const HOST = process.env['HOST'] || 'localhost';
+// oxlint-disable-next-line no-magic-numbers -- 5173 is the standard Vite dev server port
 export const PORT: number = Number(process.env['PORT']) || 5173;
 
 export default {
-    ...configDefaults,
-    webServer: {
-        ...configDefaults.webServer,
-        url: `${PROTOCOL}://${HOST}:${PORT}`,
-    },
-    use: {
-        ...configDefaults.use,
-        baseURL: `${PROTOCOL}://${HOST}:${PORT}`,
-    }
-};
+  ...configDefaults,
+  webServer: {
+    ...configDefaults.webServer,
+    url: `${PROTOCOL}://${HOST}:${PORT}`,
+  },
+  use: {
+    ...configDefaults.use,
+    baseURL: `${PROTOCOL}://${HOST}:${PORT}`,
+  },
+};

package/client-tmp/react/src/App.tsx

@@ -1,39 +1,41 @@
 import { useCallback, useEffect, useState } from 'react';
+import { Provider } from 'react-redux';
 import { BrowserRouter as Router } from 'react-router-dom';
-{{#if FDC3.channels.length~}}
-import {
-  listenToChannel,
-  onFDC3Ready,
-} from './utils';
-{{/if}}
+import AppRoutes from './components/routes/AppRoutes';
 import { customEventFactory, registerStylesTarget } from './pbc/utils';
-import { RoutesProvider } from './store/RoutesContext';
-import { registerComponents as genesisRegisterComponents } from './share/genesis-components';
 import { storeService } from './services/store.service';
-import AppRoutes from './components/routes/AppRoutes';
+import { registerComponents as genesisRegisterComponents } from './share/genesis-components';
+import { RoutesProvider } from './store/RoutesContext';
 import { reduxStore } from './store/store';
-import { Provider } from 'react-redux';
+{{#if FDC3.channels.length~}}
+import { listenToChannel, onFDC3Ready } from './utils';
+{{/if}}
 
 interface AppProps {
   rootElement: HTMLElement;
 }
 
 const App: React.FC<AppProps> = ({ rootElement }) => {
-  {{#if FDC3.channels.length~}}
-  const FDC3ReadyHandler = () => {
+  {{#if FDC3.channels.length}}
+  // Memoized so the handler keeps a stable identity and the effect below registers the
+  // channel listeners once instead of on every render.
+  const FDC3ReadyHandler = useCallback(() => {
     {{#each FDC3.channels}}
     listenToChannel('{{this.name}}', '{{this.type}}', (result) => {
-      console.log('Received FDC3 channel message on: {{this.name}} channel, type: {{this.type}}', result);
+      console.log('Received FDC3 message on {{this.name}} ({{this.type}})', result);
       // TODO: Add your listener logic here
       // E.g. open a modal or route to specific page: Route.path.push(`[Route name]`);
     });
     {{/each}}
-  };
+  }, []);
   {{/if}}
   const [componentsReady, setComponentsReady] = useState(false);
-  const dispatchCustomEvent = useCallback((type: string, detail?: unknown) => {
-    rootElement.dispatchEvent(customEventFactory(type, detail));
-  }, [rootElement]);
+  const dispatchCustomEvent = useCallback(
+    (type: string, detail?: unknown) => {
+      rootElement.dispatchEvent(customEventFactory(type, detail));
+    },
+    [rootElement],
+  );
 
   const handleStoreConnected = useCallback((event: CustomEvent) => {
     storeService.onConnected(event);
@@ -56,18 +58,14 @@ const App: React.FC<AppProps> = ({ rootElement }) => {
     rootElement.addEventListener('store-connected', handleStoreConnected as EventListener);
     dispatchCustomEvent('store-connected', rootElement);
     dispatchCustomEvent('store-ready', true);
-
-    return () => {
-      rootElement.removeEventListener(
-        'store-connected',
-        handleStoreConnected as EventListener,
-      );
-    };
-    {{#if FDC3.channels.length~}}
+    {{#if FDC3.channels.length}}
     onFDC3Ready(FDC3ReadyHandler);
     {{/if}}
 
-  }, [rootElement, handleStoreConnected, dispatchCustomEvent]);
+    return () => {
+      rootElement.removeEventListener('store-connected', handleStoreConnected as EventListener);
+    };
+  }, [rootElement, handleStoreConnected, dispatchCustomEvent{{#if FDC3.channels.length}}, FDC3ReadyHandler{{/if}}]);
 
   const baseElement = document.querySelector('base');
   const basePath = baseElement?.getAttribute('href') || '';
@@ -79,9 +77,9 @@ const App: React.FC<AppProps> = ({ rootElement }) => {
   return (
     <Provider store={reduxStore}>
       <RoutesProvider>
-          <Router basename={basePath}>
-            <AppRoutes />
-          </Router>
+        <Router basename={basePath}>
+          <AppRoutes />
+        </Router>
       </RoutesProvider>
     </Provider>
   );

package/client-tmp/react/src/__mocks__/fileMock.js

@@ -0,0 +1 @@
+module.exports = {};

package/client-tmp/react/src/components/ErrorMessage/ErrorMessage.test.tsx

@@ -42,7 +42,7 @@ describe('ErrorMessage Component', () => {
     render(<ErrorMessage message={message} />);
     const displayedMessage: HTMLElement = screen.getByText(message);
     const messageWrapper: HTMLElement | null = displayedMessage.parentElement;
-    
+
     expect(messageWrapper).toBeInTheDocument();
     expect(messageWrapper).toHaveStyle(`
       color: var(--neutral-foreground-rest);
@@ -67,9 +67,21 @@ describe('ErrorMessage Component', () => {
   });
 
   test('renders the correct element type for various elementType props', () => {
-    const elementTypes: ErrorMessageProps['elementType'][] = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'span', 'div'];
+    const elementTypes: ErrorMessageProps['elementType'][] = [
+      'h1',
+      'h2',
+      'h3',
+      'h4',
+      'h5',
+      'h6',
+      'p',
+      'span',
+      'div',
+    ];
     elementTypes.forEach((elementType: ErrorMessageProps['elementType']) => {
-      const { container }: { container: HTMLElement } = render(<ErrorMessage message={message} elementType={elementType} />);
+      const { container }: { container: HTMLElement } = render(
+        <ErrorMessage message={message} elementType={elementType} />,
+      );
       const displayedMessage: HTMLElement | null = container.querySelector(elementType as string);
       expect(displayedMessage).toBeInTheDocument();
       expect(displayedMessage?.tagName).toBe((elementType as string).toUpperCase());
@@ -92,4 +104,4 @@ describe('ErrorMessage Component', () => {
     const { container }: { container: HTMLElement } = render(<ErrorMessage message={undefined} />);
     expect(container.firstChild).toBeNull();
   });
-});
+});

package/client-tmp/react/src/components/ErrorMessage/ErrorMessage.tsx

@@ -22,7 +22,7 @@ const styles = {
     width: 'fit-content',
     alignSelf: 'center',
     height: 'auto',
-    maxHeight: '100%'
+    maxHeight: '100%',
   },
 };
 
@@ -34,34 +34,37 @@ export interface ErrorMessageProps {
 const ErrorMessage: React.FC<ErrorMessageProps> = ({ elementType = 'div', message = '' }) => {
   const ElementType = elementType;
 
-  return message && message !== '' && (
-    <section style={styles.errorMessageWrapper}>
-      <div style={styles.errorMessage}>
-        {(() => {
-          switch (ElementType) {
-            case 'h1':
-              return <h1>{message}</h1>;
-            case 'h2':
-              return <h2>{message}</h2>;
-            case 'h3':
-              return <h3>{message}</h3>;
-            case 'h4':
-              return <h4>{message}</h4>;
-            case 'h5':
-              return <h5>{message}</h5>;
-            case 'h6':
-              return <h6>{message}</h6>;
-            case 'p':
-              return <p>{message}</p>;
-            case 'span':
-              return <span>{message}</span>;
-            default:
-              return <div>{message}</div>;
-          }
-        })()}
-      </div>
-    </section>
+  return (
+    message &&
+    message !== '' && (
+      <section style={styles.errorMessageWrapper}>
+        <div style={styles.errorMessage}>
+          {(() => {
+            switch (ElementType) {
+              case 'h1':
+                return <h1>{message}</h1>;
+              case 'h2':
+                return <h2>{message}</h2>;
+              case 'h3':
+                return <h3>{message}</h3>;
+              case 'h4':
+                return <h4>{message}</h4>;
+              case 'h5':
+                return <h5>{message}</h5>;
+              case 'h6':
+                return <h6>{message}</h6>;
+              case 'p':
+                return <p>{message}</p>;
+              case 'span':
+                return <span>{message}</span>;
+              default:
+                return <div>{message}</div>;
+            }
+          })()}
+        </div>
+      </section>
+    )
   );
 };
 
-export default ErrorMessage;
+export default ErrorMessage;

package/client-tmp/react/src/components/error-boundary/ErrorBoundary.tsx

@@ -27,6 +27,9 @@ type BaseErrorBoundaryState = {
   referenceId: string;
 };
 
+/** Cap on the ring buffer of error reports exposed to genesis-telemetry.js. */
+const MAX_ERROR_BOUNDARY_REPORTS = 20;
+
 const initialBoundaryState: BaseErrorBoundaryState = {
   hasError: false,
   error: null,
@@ -53,6 +56,7 @@ const toError = (value: unknown): Error => {
 
 const createReferenceId = (): string => {
   const timestamp = new Date().toISOString().split(':').join('-');
+  // oxlint-disable-next-line no-magic-numbers -- base-36 encoding with 6-char slice is a well-known ID generation pattern
   const random = Math.random().toString(36).slice(2, 8).toUpperCase();
   return `APP-${timestamp}-${random}`;
 };
@@ -68,6 +72,8 @@ const ErrorBoundaryFallback: React.FC<ErrorBoundaryFallbackProps> = ({
   const [copied, setCopied] = useState(false);
   const [copyHelpVisible, setCopyHelpVisible] = useState(false);
 
+  const COPY_RESET_DELAY_MS = 2_000;
+
   const handleCopy = async () => {
     try {
       await navigator.clipboard.writeText(details);
@@ -75,7 +81,7 @@ const ErrorBoundaryFallback: React.FC<ErrorBoundaryFallbackProps> = ({
       setCopyHelpVisible(false);
       window.setTimeout(() => {
         setCopied(false);
-      }, 2_000);
+      }, COPY_RESET_DELAY_MS);
     } catch {
       setCopyHelpVisible(true);
     }
@@ -155,8 +161,13 @@ class BaseErrorBoundary extends React.Component<BaseErrorBoundaryProps, BaseErro
 
     // Expose to genesis-telemetry.js so the UI Builder agent can read it via get_preview_diagnostics
     const reports: unknown[] = ((window as any).__GENESIS_ERROR_BOUNDARY_REPORTS__ ??= []);
-    reports.push({ message: normalized.message, stack: normalized.stack ?? null, componentStack: errorInfo.componentStack ?? null, ts: Date.now() });
-    if (reports.length > 20) reports.shift();
+    reports.push({
+      message: normalized.message,
+      stack: normalized.stack ?? null,
+      componentStack: errorInfo.componentStack ?? null,
+      ts: Date.now(),
+    });
+    if (reports.length > MAX_ERROR_BOUNDARY_REPORTS) reports.shift();
   }
 
   private readonly handleRetry = (): void => {
@@ -186,9 +197,7 @@ class BaseErrorBoundary extends React.Component<BaseErrorBoundaryProps, BaseErro
     ].join('\n');
 
     const fallbackTitle =
-      scope === 'application'
-        ? 'Something went wrong'
-        : `Something went wrong in "${title}"`;
+      scope === 'application' ? 'Something went wrong' : `Something went wrong in "${title}"`;
     const fallbackSubtitle =
       scope === 'application'
         ? 'The app hit an unexpected error. You can retry or copy diagnostics for a fast fix.'

package/client-tmp/react/src/components/routes/AppRoutes.tsx

@@ -2,10 +2,10 @@ import { renderAppRoutes } from '@genesislcap/foundation-react-utils/router';
 import DefaultLayout from '../../layouts/default/DefaultLayout';
 import NotFoundPage from '../../pages/NotFoundPage/NotFoundPage.tsx';
 import { useRoutesContext } from '../../store/RoutesContext';
-import ProtectedRoute from './ProtectedRoute';
 {{#if routes.[0]}}
 import SingleComponent, { initialComponentName } from '../single-component/SingleComponent';
 {{/if}}
+import ProtectedRoute from './ProtectedRoute';
 
 /**
  * Builds the app's `<Routes>` from the declarative route table (see RoutesContext)

package/client-tmp/react/src/components/single-component/registry.ts

@@ -1,7 +1,11 @@
 import { createComponentRegistry } from '@genesislcap/foundation-react-utils/router';
+{{#if routes.[0]}}
+/* eslint-disable import-es/order -- generated route pages follow route-table order, not alphabetical */
 {{#each routes}}
 import {{pascalCase this.name}} from '../../pages/{{pascalCase this.name}}/{{pascalCase this.name}}';
 {{/each}}
+/* eslint-enable import-es/order */
+{{/if}}
 
 /**
  * Registry of components that can be rendered standalone via the

package/client-tmp/react/src/custom-elements.d.ts

@@ -1,8 +1,10 @@
 import React, { DOMAttributes } from 'react';
 
-type CustomElement<T = React.HTMLAttributes<HTMLElement>> = Partial<T & DOMAttributes<T> & { [key: string]: any }>;
+type CustomElement<T = React.HTMLAttributes<HTMLElement>> = Partial<
+  T & DOMAttributes<T> & { [key: string]: any }
+>;
 
-declare module "react/jsx-runtime" {
+declare module 'react/jsx-runtime' {
   namespace JSX {
     interface IntrinsicElements {
       'rapid-design-system-provider': CustomElement;

package/client-tmp/react/src/helpers/hasPermissionHelper.tsx

@@ -8,4 +8,4 @@ const hasPermissionHelper = (permissionCode: string | undefined): boolean => {
   return getUser().hasPermission(permissionCode);
 };
 
-export default hasPermissionHelper;
+export default hasPermissionHelper;

package/client-tmp/react/src/helpers/isAuthenticatedHelper.tsx

@@ -11,4 +11,4 @@ const isAuthenticatedHelper = (): boolean => {
   return true;
 };
 
-export default isAuthenticatedHelper;
+export default isAuthenticatedHelper;

package/client-tmp/react/src/helpers/isConnectedHelper.tsx

@@ -5,12 +5,12 @@ const isConnectedHelper = (): Promise<boolean> => {
   const hostUrl = sessionStorage.getItem('hostUrl');
 
   if (connect.isConnected) {
-    return new Promise((resolve) => resolve(true));
+    return Promise.resolve(true);
   }
   if (!hostUrl) {
-    return new Promise((resolve) => resolve(false));
+    return Promise.resolve(false);
   }
   return connect.connect(hostUrl);
 };
 
-export default isConnectedHelper;
+export default isConnectedHelper;