Add aliases to vite.config.ts

```js import { defineConfig } from 'vite' import react from '@vitejs/plugin-react' import path from 'path';

// https://vitejs.dev/config/ export default defineConfig({ resolve: { alias: { '@': path.resolve(__dirname, './src'), '@assets': path.resolve(__dirname, './src/assets'), '@components': path.resolve(__dirname, './src/components'), }, }, plugins: [react()] }) ```

Add aliases to tsconfig.json

```js { "compilerOptions": { // ... your other compiler options "baseUrl": ".", "paths": { "@/": ["src/"], "@components/": ["src/components/"], "@assets/": ["src/assets/"] }, }, "include": ["src"], "references": [{ "path": "./tsconfig.node.json" }] } ````

Use alias

js import image from `@assets/image.png`

npx -p typescript tsc src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types

js /** * This component is just a Box with border. * It serves as an example of how you can incorporate * components together. * * Component also has slots, methods and events. * * @component * @example <caption>Basic usage just with the default slot</caption> * <Box> * I am inside a slot * </Box> * * @example <caption>Using second component inside</caption> * <Box> * <ProgressBar :spent="spent" :remaining="50"></ProgressBar> * </Box> * * @example <caption>Example of passing an entire component in a preview</caption> * { * template: `<Box> * <ProgressBar :spent="spent" :remaining="50"></ProgressBar> * <ProgressBar :spent="50" :remaining="50" style="margin-top: 20px"></ProgressBar> * </Box>`, * data: function() { * return {spent: 223}; * } * } */ export default { name: "Box", props: { /** * This will be in the header */ title: { type: String, default: "My box" } }, methods: { /** * Also, you can describe methods for each component * the same as you would do this in regular @jsdoc * documented file * * @param {string} prop1 some example property * @param {string} prop2 other property */ exampleMethod(prop1, prop2) { // method body // The method could even throw an event /** * This event could be thrown by component in case * of some kind of unexpected behaviour. * * @category API * @event unexpectedEvent */ this.$emit('unexpecteEvent') } } }

```ts

/* * Initiates a connection to the selected port. / async function connectToServer(): Promise<void> { hostInput.disabled = true; portInput.disabled = true; connectButton.textContent = 'Connecting...'; connectButton.disabled = true;

try { socket = new TCPSocket(hostInput.value, parseInt(portInput.value)); connection = await socket.opened; term.writeln('<CONNECTED>'); connectButton.textContent = 'Disconnect'; connectButton.disabled = false; } catch (e) { console.error(e); term.writeln(<ERROR: ${e.message}>); markDisconnected(); return; }

try { reader = connection?.readable.getReader(); for (;;) { const {value, done} = await reader.read(); if (value) { await new Promise<void>((resolve) => { term.write(value, resolve); }); } if (done) { break; } } reader.releaseLock(); reader = undefined; } catch (e) { console.error(e); term.writeln(<ERROR: ${e.message}>); }

markDisconnected(); }

/* * Closes the currently active connection. / async function disconnectFromServer(): Promise<void> { // Canceling |reader| will close the connection and cause the read loop in // connectToServer() to exit when read() returns with done set to true. if (reader) { await reader.cancel(); } } ```

ts declare module "@remix-run/server-runtime" { export interface AppLoadContext { name: string; } }

ts const myArray:readonly[number, string] = [10, 'test'];

Mutating a Typescript Tuple

```ts let myTuple:[ string, number ] = [ "some", 15 ]

myTuple[1] = 20; ```

ts let myTuple:[ string, number ][] = [ [ "some", 15 ], [ "other", 20 ], [ "tuple", 50 ] ];

ts const myTuple:[ string, number ] = [ "some", 15 ]

```ts type ColorDSValue = "black100" | "black80" | "blue100" | "red150" // | etc type ColorOtherString = string & {}

type Color = ColorDSValue | ColorOtherString ```

ts const wow: ("hello" | "world") | (string & {}) // `wow` is of type `"hello"` or `"world"` or `string`.

an alternative to !!, in order to convert null, empty strings, boolean values into 0 or 1.

// a 'Person' object requires 'first' and 'last' 
// properties whose values are strings
interface Person {
  first: string;
  last: string;
}

// This defines that the first functional argument 
// must be an Array of 'Person' objects, then destructs
// the first person's first and last name properties
const helloFirstPerson = ([{ first, last }]: Person[]) =>
  `Hello ${first} ${last}!`;

const people = [
  { first: 'John', last: 'Doe' },
  { first: 'Jane', last: 'Smith' }
];

// outputs "Hello John Doe!"
helloFirstPerson(people);

/* --------- Example of a Type Error ----------- */
// This creates an array argument that will be invalid for
// the helloFirstPerson() function, because there are no 'last'
// props on the 'people' objects
const badArgs = [{ first: 'John' }, { first: 'Jane' } ];

// Type Error! 
// Property 'last' is missing in type '{ first: string; }'
helloFirstPerson(badArgs);

Train, Validation, Test: 0.7, 0.2, 0.1

最简单的 FC props定义方式

Mataix-Cols, D., Ringberg, H., & de la Cruz, L. F. (2020, May 5). Perceived worsening of tics in adult patients with Tourette syndrome after the COVID-19 outbreak. https://doi.org/10.31234/osf.io/vr8km

boilerplate