Template projeto Typescript

.eslintrc.js

module.exports = {
    env: {
        es2021: true,
        node: true,
        jest: true,
    },
    extends: ['airbnb-base', 'prettier'],
    parser: '@typescript-eslint/parser',
    parserOptions: {
        ecmaVersion: 12,
        sourceType: 'module',
    },
    plugins: ['@typescript-eslint', 'import'],
    rules: {
        '@typescript-eslint/no-unused-vars': 'error',
        'no-unused-vars': 'off',
        'no-shadow': 'off',
        'class-methods-use-this': 'off',
        'no-console': 'warn',
        '@typescript-eslint/no-shadow': ['error'],
        'import/prefer-default-export': 0,
        'import/no-cycle': 0,
        'import/extensions': [
            'error',
            'ignorePackages',
            {
                js: 'never',
                jsx: 'never',
                ts: 'never',
                tsx: 'never',
            },
        ],
    },
    settings: {
        'import/resolver': {
            node: {
                extensions: ['.js', '.jsx', '.ts', '.tsx'],
            },
            alias: {
                map: [['@src', './src']],
                extensions: ['.js', '.jsx', '.ts', '.tsx'],
            },
        },
        react: {
            version: 'latest',
        },
    },
};

.gitignore

# Custom
build


# Created by https://www.toptal.com/developers/gitignore/api/node,visualstudiocode,macos
# Edit at https://www.toptal.com/developers/gitignore?templates=node,visualstudiocode,macos

### macOS ###
# General
.DS_Store
.AppleDouble
.LSOverride

# Icon must end with two \r
Icon


# Thumbnails
._*

# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent

# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk

### Node ###
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
.pnpm-debug.log*

# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage
*.lcov

# nyc test coverage
.nyc_output

# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# Bower dependency directory (https://bower.io/)
bower_components

# node-waf configuration
.lock-wscript

# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release

# Dependency directories
node_modules/
jspm_packages/

# Snowpack dependency directory (https://snowpack.dev/)
web_modules/

# TypeScript cache
*.tsbuildinfo

# Optional npm cache directory
.npm

# Optional eslint cache
.eslintcache

# Microbundle cache
.rpt2_cache/
.rts2_cache_cjs/
.rts2_cache_es/
.rts2_cache_umd/

# Optional REPL history
.node_repl_history

# Output of 'npm pack'
*.tgz

# Yarn Integrity file
.yarn-integrity

# dotenv environment variables file
.env
.env.test
.env.production

# parcel-bundler cache (https://parceljs.org/)
.cache
.parcel-cache

# Next.js build output
.next
out

# Nuxt.js build / generate output
.nuxt
dist

# Gatsby files
.cache/
# Comment in the public line in if your project uses Gatsby and not Next.js
# https://nextjs.org/blog/next-9-1#public-directory-support
# public

# vuepress build output
.vuepress/dist

# Serverless directories
.serverless/

# FuseBox cache
.fusebox/

# DynamoDB Local files
.dynamodb/

# TernJS port file
.tern-port

# Stores VSCode versions used for testing VSCode extensions
.vscode-test

# yarn v2
.yarn/cache
.yarn/unplugged
.yarn/build-state.yml
.yarn/install-state.gz
.pnp.*

### Node Patch ###
# Serverless Webpack directories
.webpack/

# Optional stylelint cache
.stylelintcache

# SvelteKit build / generate output
.svelte-kit

### VisualStudioCode ###
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
*.code-workspace

# Local History for Visual Studio Code
.history/

### VisualStudioCode Patch ###
# Ignore all local history of files
.history
.ionide

# Support for Project snippet scope
!.vscode/*.code-snippets

# End of https://www.toptal.com/developers/gitignore/api/node,visualstudiocode,macos

.gitlab-ci.yml

include:
    - https://gitlab.usign.io/nelio.santos/ci-templates/-/raw/master/template-typescript.yaml
    - https://gitlab.usign.io/nelio.santos/ci-templates/-/raw/master/template-docker.yaml
    - https://gitlab.usign.io/nelio.santos/ci-templates/-/raw/master/template-deploy.yaml

stages:
    - checks
    - install
    - tests
    - build
    - image
    - deploy

cache:
    key: "$CI_COMMIT_SHORT_SHA"
    paths:
        - build
        - node_modules

.husky_pre-commit

#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

npm run lint && \
    npm version patch --no-git-tag-version && \
    git add package.json package-lock.json

.prettierrc.js

module.exports = {
    arrowParens: "always",
    bracketSameLine: false,
    bracketSpacing: true,
    embeddedLanguageFormatting: "auto",
    htmlWhitespaceSensitivity: "css",
    insertPragma: false,
    jsxSingleQuote: false,
    printWidth: 80,
    proseWrap: "preserve",
    quoteProps: "as-needed",
    requirePragma: false,
    semi: true,
    singleQuote: true,
    tabWidth: 4,
    trailingComma: "es5",
    useTabs: false,
    vueIndentScriptAndStyle: false,
};

README.md

Introdução

Template para projetos em typescript

Desenvolvimento

Pre-requisitos

Para utilizar este projeto você precisará ter os seguintes softwares instalados:

• Docker 19.x ou superior;
• Nodejs versão 16.x (especifica);
• VSCode ou Neovim;

Ambiente

Para inicializar o ambiente de desenvolvimento, utilize:

npm install
npm start

Dockerfile

FROM node:16

WORKDIR /app
COPY package*.json /app/

RUN npm install

COPY build ./
COPY entrypoint.sh ./

ENTRYPOINT [ "/app/entrypoint.sh" ]
CMD [ "wait" ]

entrypoint.sh

#!/bin/sh

if [ "x$@" = "xwait" ] ; then
    while true ; do
        date
        node index.js
        sleep 300
    done
else
    echo Executando comando: $@
    $@
fi
sleep 60

jest.config.js

/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
    roots: ['./src'],
    transform: {
        '^.+\\.tsx?$': 'ts-jest',
    },
    setupFiles: ['dotenv/config'],
    moduleFileExtensions: ['js', 'jsx', 'json', 'ts', 'tsx', 'node'],
    moduleDirectories: ['node_modules', 'bower_components', './src'],
};

prepare.js

#!/usr/bin/env node

const { readFileSync, writeFileSync } = require("fs");

const praw = readFileSync("package.json").toString();
const pjson = JSON.parse(praw);

const additionalConfig = { 
    "nodemonConfig": {
        "watch": [
            "src/",
        ],
        "ignore": [
            ".git",
            "node_modules"
        ],
        "execMap": {
            "ts": "node --require ts-node/register"
        },
        "env": {
        }
    },
}

writeFileSync("package.json", JSON.stringify({
    ...pjson,
    ...additionalConfig,
}, null, 4));

prepare.sh

#!/bin/bash

function typescript-download {
    GIST="https://gist.githubusercontent.com/nsfilho/aaaa7afeb3169a695efb3231c6d37c82/raw"
    nomeArquivo=$1
    if [ ! -f $nomeArquivo ] ; then
        nomeDownload=$(echo $nomeArquivo | sed "s/\//_/g")
        wget -O $nomeArquivo "$GIST/$nomeDownload"
    fi
}

echo "Preparando projeto..."
if [ ! -f package.json ] ; then
    npm init -y
fi

if [ ! -d .git ] ; then
    git init
fi

npm pkg set scripts.start="DEBUG=core,utils nodemon src/index.ts"
npm pkg set scripts.lint="eslint --fix src/**/*.ts"
npm pkg set scripts.prepare="husky install"
npm pkg set scripts.postlint="tsc --noEmit -p tsconfig.json"
npm pkg set scripts.format="prettier --write src/**/*.ts package.json"
npm pkg set scripts.build="tsc"
npm pkg set scripts.test="jest --detectOpenHandles --coverage"

npm install --save-dev @types/node @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint \
    eslint-config-airbnb-base eslint-config-prettier eslint-plugin-import prettier ts-node typescript \
    husky @types/debug @types/jest jest ts-jest nodemon

npm install debug axios dayjs [email protected] dotenv
npx husky install

typescript-download README.md
typescript-download .eslintrc.js
typescript-download tsconfig.json
typescript-download .prettierrc.js
typescript-download Dockerfile
typescript-download entrypoint.sh
typescript-download .gitlab-ci.yml
typescript-download .gitignore
typescript-download jest.config.js

if [ -f entrypoint.sh ] ; then
    chmod a+rx entrypoint.sh
fi

if [ ! -d src ] ; then
    mkdir src
fi

if [ ! -d src/constants ] ; then
    mkdir src/constants
fi

typescript-download "src/index.ts"
typescript-download "src/utils.ts"
typescript-download "src/usign.ts"
typescript-download "src/constants/index.ts"
typescript-download "src/constants/usign.ts"
typescript-download ".husky/pre-commit"

if [ -f .husky/pre-commit ] ; then
    chmod a+rx .husky/pre-commit
fi

# Last settings
typescript-download prepare.js
node prepare.js
rm -f prepare.js prepare.sh
ls -la

src_constants_index.ts

export * from './usign';

src_constants_usign.ts

export const USIGN_USERNAME = process.env.USIGN_USERNAME || '';
export const USIGN_PASSWORD = process.env.USIGN_PASSWORD || '';
export const USIGN_API = process.env.USIGN_API || 'https://api.fusion.usign.io';
export const USIGN_ASSETS = process.env.USIGN_ASSETS || 'https://devt7g9tfxj67.cloudfront.net';

src_index.ts

import 'dotenv/config';
import debug from 'debug';
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc';
import timezone from 'dayjs/plugin/timezone';

dayjs.extend(utc);
dayjs.extend(timezone);

const logger = debug('core');

const bootstrap = async () => {
    logger('Starting...');
};

bootstrap().catch((err) => {
    logger('General fail: %O', err);
});

src_usign.ts

import axios, { AxiosInstance, AxiosRequestHeaders } from 'axios';
import debug from 'debug';
import {
    USIGN_API,
    USIGN_USERNAME,
    USIGN_PASSWORD,
    USIGN_ASSETS,
} from './constants';
import { retry } from './utils';

const logger = debug('uSign');

interface loginOptions {
    username?: string;
    password?: string;
    api?: string;
}

interface findOptions {
    path: string;
    domain?: string;
}

interface updateOptions<T> {
    path: string;
    data: T;
    domain?: string;
}

interface uSignApiResponse<K> {
    data: K;
}

export interface uSignDomain {
    _id: string;
    nome: string;
    legenda: string;
}

export interface uSignFileUpload {
    isCustomThumbnail: boolean;
    _id: string;
    fileName: string;
    urlOriginal: string;
    originalName: string;
    contentType: string;
    contentLength: number;
    thumbnail: string;
}

export interface uSignRecordFramework {
    status: string;
    sistema: boolean;
    bancoDeDados: string;
    criadorPor: string;
    dominio: string | uSignDomain;
    dataCriacao: string;
    dataAtualizacao: string;
}

export interface uSignRecord {
    _id: string;
    framework: uSignRecordFramework;
}

export interface uSignCustomRecord<L> extends uSignRecord {
    formulario: null | string;
    entidade: string;
    dados: L;
}

export interface uSignCustomRecordSend<L> {
    _id?: string;
    framework: Partial<uSignRecordFramework>;
    formulario: null | string;
    entidade: string;
    dados: L;
}

export interface getMediaStorageUrlOptions {
    id: string;
    domain?: string;
}

export interface MediaStorageRecord extends uSignRecord {
    playlists: number;
    isCustomThumbnail: boolean;
    fileName: string;
    hash: {
        sha256: string;
    };
    part: {
        length: number;
        md5: string;
    };
    user: {
        nome: {
            titulo: string;
            primeiro: string;
            sobrenome: string;
        };
        _id: string;
    };
    domain: {
        _id: string;
        legenda: string;
    };
    duration: number;
    name: string;
    legend: string;
    urlOriginal: string;
    originalName: string;
    contentType: string;
    contentLength: number;
    tags: {
        _id: string;
        name: string;
    }[];
    thumbnail: string;
    description: string;
}

export class USign {
    private username: string;

    private password: string;

    private api: string;

    private token: string;

    private ax: AxiosInstance | null;

    constructor() {
        this.username = USIGN_USERNAME;
        this.password = USIGN_PASSWORD;
        this.api = USIGN_API;
        this.ax = null;
        this.token = '';
    }

    public async login({ username, password, api }: loginOptions = {}) {
        if (username) this.username = username;
        if (password) this.password = password;
        if (api) this.api = api;

        this.ax = axios.create();
        const result = await retry(
            () =>
                this.ax!.post(`${this.api}/usuario/login`, {
                    usuario: this.username,
                    senha: this.password,
                }),
            10,
            1000,
            `trying to login on uSign (user: ${this.username})`
        );
        if (result.status === 200) {
            logger(`Login successful: ${result.data.token}`);
            this.token = result.data.token;
            this.ax.defaults.headers.common.Authorization = `Bearer ${result.data.token}`;
        }
    }

    private getHeaderDomain(domain?: string): Record<string, string> {
        return domain
            ? {
                  'X-Domain': domain,
              }
            : {};
    }

    private getHeaders(domain?: string): Record<string, string> {
        return {
            Authorization: `Bearer ${this.token}`,
            ...this.getHeaderDomain(domain),
        };
    }


    public async find<T>({ path, domain }: findOptions): Promise<T[]> {
        if (!this.ax) throw new Error('login first please');

        const sum: T[] = [];
        for (let page = 1; ; page += 1) {
            // eslint-disable-next-line no-await-in-loop
            const result = await retry(
                () =>
                    this.ax!.get<uSignApiResponse<T[]>>(
                        `${this.api}${path}?tree=true&noCache=true&page=${page}&perPage=100`,
                        {
                            headers: this.getHeaders(domain),
                        }
                    ),
                10,
                1000,
                `trying to get data from uSign, ${path}, page: ${page}`
            );
            if (result.data.data.length === 0) break;
            sum.push(...result.data.data);
        }
        return sum;
    }

    public async get<T>({
        path,
        domain,
    }: findOptions): Promise<uSignApiResponse<T>> {
        if (!this.ax) throw new Error('login first please');
        const answer = await retry(
            () =>
                this.ax!.get<uSignApiResponse<T>>(`${this.api}${path}`, {
                    headers: this.getHeaders(domain),
                }),
            10,
            1000,
            `trying to get a record from uSign: ${path}`
        );
        return answer.data;
    }

    public async getMediaStorageUrl({
        id,
        domain,
    }: getMediaStorageUrlOptions): Promise<string> {
        const record = await this.get<MediaStorageRecord>({
            path: `/mediaStorage/${id}`,
            domain,
        });
        return `${USIGN_ASSETS}/${record.data.fileName}`;
    }

    public async update<T>({
        path,
        data,
        domain,
    }: updateOptions<T>): Promise<void> {
        if (!this.ax) throw new Error('login first please');
        const rawData = await retry(
            () =>
                this.ax!.put(`${this.api}${path}`, data, {
                    headers: this.getHeaders(domain),
                }),
            10,
            1000,
            `trying to update record: ${path}`
        );
        return rawData.data.data;
    }

    public async insert<T>({
        path,
        data,
        domain,
    }: updateOptions<T>): Promise<void> {
        if (!this.ax) throw new Error('login first please');
        const rawData = await retry(
            () =>
                this.ax!.post(`${this.api}${path}`, data, {
                    headers: this.getHeaders(domain),
                }),
            10,
            1000,
            `trying to insert record: ${path}`
        );
        return rawData.data.data;
    }
}

export const usign = new USign();

src_utils.ts

/* eslint-disable no-await-in-loop */
import debug from 'debug';

const logger = debug('utils');

export const removeAccents = (text: string) => text.normalize('NFD').replace(/\p{Diacritic}/gu, '');

// eslint-disable-next-line no-unused-vars
type Callback<T, R> = (item: T, workerId: number) => Promise<R>;

export const throttle = async <T, R>(lista: T[], callback: Callback<T, R>, simultaneous: number) => {
    const parallels: number[] = [];
    for (let x = 1; x <= simultaneous; x += 1) parallels.push(x);

    return Promise.all(
        parallels.map((workerId) => {
            const job = async () => {
                for (; lista.length > 0; ) {
                    const item = lista.shift() as T;
                    await callback(item, workerId);
                }
            };
            return job();
        }),
    );
};

export const delay = async (timeout = 1000) =>
    new Promise((resolve) => {
        setTimeout(resolve, timeout);
    });

type CallbackRetry<T> = () => Promise<T>;

export const retry = async <T>(
    cb: CallbackRetry<T>,
    maxRetries = 10,
    delayTimeout = 1000,
    description = '',
): Promise<T> => {
    for (let tentative = 1; tentative <= maxRetries; tentative += 1) {
        try {
            const result: T = await cb();
            return result;
        } catch (err) {
            logger(`Retry: ${tentative}/${maxRetries} [${description}] - Error: ${err}`);
            await delay(delayTimeout);
        }
    }
    throw Error(`Exceeded ${maxRetries} for ${description || 'call function'}`);
};

tsconfig.json

{
  "compilerOptions": {
    /* Visit https://aka.ms/tsconfig to read more about this file */

    /* Projects */
    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */

    /* Language and Environment */
    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */

    /* Modules */
    "module": "commonjs",                                /* Specify what module code is generated. */
    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
    // "resolveJsonModule": true,                        /* Enable importing .json files. */
    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */

    /* JavaScript Support */
    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */

    /* Emit */
    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
    "outDir": "./build",                                   /* Specify an output folder for all emitted files. */
    // "removeComments": true,                           /* Disable emitting comments. */
    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */

    /* Interop Constraints */
    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */

    /* Type Checking */
    "strict": true,                                      /* Enable all strict type-checking options. */
    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */

    /* Completeness */
    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
  }
}