refactor: add assertion utils separately for main and renderer

packages/app-common/package.json

@@ -42,7 +42,6 @@
         "lint": "eslint .",
         "pre-commit": "lint-staged",
         "test": "unit-test",
-        "test-full": "unit-test",
         "typecheck": "tsc --project tsconfig.json --noEmit"
     },
     "devDependencies": {

packages/app-common/src/utils/index.ts

@@ -1,2 +1 @@
-export * from './assert';
 export * from './function';

packages/app-main/src/main/utils/assert/__tests__/__snapshots__/index.test.ts.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Test fn \`assertIsNever\` should throw an error 1`] = `""hello world" should be "never" type."`;

packages/app-main/src/main/utils/assert/__tests__/index.test.ts

@@ -0,0 +1,10 @@
+import { AssertionError } from 'node:assert';
+
+import { assertIsNever } from '../index';
+
+describe(`Test fn \`${assertIsNever.name}\``, () => {
+    it('should throw an error', () => {
+        expect(() => assertIsNever('hello world' as never)).toThrow(AssertionError);
+        expect(() => assertIsNever('hello world' as never)).toThrowErrorMatchingSnapshot();
+    });
+});

packages/app-main/src/main/utils/assert/index.ts

@@ -0,0 +1,8 @@
+import { AssertionError } from 'node:assert';
+
+/**
+ * The function for asserting whether a value's type is `never`.
+ */
+export function assertIsNever(value: never): never {
+    throw new AssertionError({ message: `"${String(value)}" should be "never" type.` });
+}

packages/app-main/src/main/window/windowManager.ts

@@ -1,6 +1,7 @@
 import { WindowType } from '@ter/app-common/apis/app';
 import type { Nullable } from '@ter/app-common/types';
-import { assertIsNever } from '@ter/app-common/utils';
+
+import { assertIsNever } from '../utils/assert';
 
 import type { AbstractWindow } from './abstractWindow';
 import { MainWindow } from './mainWindow';

packages/app-renderer/src/hooks/__tests__/usePersistFn.test.tsx

@@ -1,9 +1,10 @@
 import type { Nullable } from '@ter/app-common/types';
-import { assert, noop } from '@ter/app-common/utils';
+import { noop } from '@ter/app-common/utils';
 import { act, render } from '@testing-library/react';
 import { useState } from 'react';
 
 import { validateHookValueNotChanged } from 'src/__tests__/hook';
+import { assert } from 'src/utils/assert';
 
 import { usePersistFn } from '../usePersistFn';
 

packages/app-renderer/src/index.tsx

@@ -1,5 +1,4 @@
 import { WindowType } from '@ter/app-common/apis/app';
-import { assert } from '@ter/app-common/utils';
 import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
 
@@ -8,14 +7,17 @@ import './index.css';
 import { appAPI } from './apis';
 import { MainWindow } from './MainWindow';
 import { reportWebVitals } from './reportWebVitals';
+import { assert, assertIsNever } from './utils/assert';
 
-function Window(): JSX.Element | null {
+function Window(): JSX.Element {
     const type = appAPI.windowType;
 
-    // eslint-disable-next-line default-case
     switch (type) {
         case WindowType.MAIN:
             return <MainWindow />;
+
+        default:
+            assertIsNever(type);
     }
 }
 

packages/app-renderer/src/utils/assert/__tests__/__snapshots__/index.test.ts.snap

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Test fn \`assert\` should assert an expression 1`] = `"Assertion Error."`;
+
+exports[`Test fn \`assertIsNever\` should throw an error 1`] = `"hello world should be "never" type."`;

packages/app-common/src/utils/__tests__/assert.test.ts → packages/app-renderer/src/utils/assert/__tests__/index.test.ts

@@ -1,16 +1,18 @@
-import { assert, assertIsNever } from '../assert';
+import { AssertionError, assert, assertIsNever } from '../index';
 
 describe(`Test fn \`${assert.name}\``, () => {
     it('should assert an expression', () => {
         const str = 'hello world';
 
         expect(() => assert(typeof str === 'string')).not.toThrow();
-        expect(() => assert(typeof str === 'number')).toThrow();
+        expect(() => assert(typeof str === 'number')).toThrow(AssertionError);
+        expect(() => assert(typeof str === 'number')).toThrowErrorMatchingSnapshot();
     });
 });
 
 describe(`Test fn \`${assertIsNever.name}\``, () => {
     it('should throw an error', () => {
-        expect(() => assertIsNever('hello world' as never)).toThrow();
+        expect(() => assertIsNever('hello world' as never)).toThrow(AssertionError);
+        expect(() => assertIsNever('hello world' as never)).toThrowErrorMatchingSnapshot();
     });
 });

packages/app-renderer/src/utils/assert/index.ts

@@ -0,0 +1,17 @@
+export class AssertionError extends Error {}
+
+/**
+ * @param value The input that is checked for being truthy.
+ */
+export function assert(value: unknown, message?: string): asserts value {
+    if (!value) {
+        throw new AssertionError(message ?? 'Assertion Error.');
+    }
+}
+
+/**
+ * The function for asserting whether a value's type is `never`.
+ */
+export function assertIsNever(value: never): never {
+    throw new AssertionError(`${String(value)} should be "never" type.`);
+}