@artsy/dismissible 0.1.0

package/.autorc

@@ -0,0 +1,3 @@
+{
+  "extends": "@artsy"
+}

package/.circleci/config.yml

@@ -0,0 +1,42 @@
+version: 2.1
+
+orbs:
+  yarn: artsy/yarn@6.2.0
+  auto: artsy/auto@2.1.0
+
+workflows:
+  build_and_verify:
+    jobs:
+      - yarn/workflow-queue
+      - yarn/update-cache:
+          requires:
+            - yarn/workflow-queue
+      - yarn/lint:
+          requires:
+            - yarn/workflow-queue
+      - yarn/type-check:
+          requires:
+            - yarn/workflow-queue
+      - yarn/test:
+          requires:
+            - yarn/workflow-queue
+      - auto/publish-canary:
+          context: npm-deploy
+          filters:
+            branches:
+              ignore: main
+          requires:
+            - yarn/test
+            - yarn/lint
+            - yarn/type-check
+            - yarn/update-cache
+      - auto/publish:
+          context: npm-deploy
+          filters:
+            branches:
+              only: main
+          requires:
+            - yarn/test
+            - yarn/lint
+            - yarn/type-check
+            - yarn/update-cache

package/.eslintrc.js

@@ -0,0 +1,31 @@
+// @ts-ignore
+module.exports = {
+  env: {
+    es6: true,
+    browser: true,
+    jest: true,
+    node: true,
+  },
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier",
+  ],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaFeatures: {
+      jsx: true,
+    },
+    ecmaVersion: 12,
+    sourceType: "module",
+  },
+  plugins: ["@typescript-eslint", "prettier"],
+  rules: {
+    "@typescript-eslint/ban-ts-comment": 0,
+    "@typescript-eslint/ban-ts-ignore": 0,
+    "@typescript-eslint/explicit-function-return-type": 0,
+    "@typescript-eslint/explicit-module-boundary-types": 0,
+    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    "prettier/prettier": 0,
+  },
+}

package/.husky/post-merge

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn pull-lock

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn lint-staged

package/.husky/pre-push

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn type-check

package/.lintstagedrc.json

@@ -0,0 +1,6 @@
+{
+  "*.ts?(x)": [
+    "eslint --fix",
+    "prettier --write"
+  ]
+}

package/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": false
+}

package/.vscode/settings.json

@@ -0,0 +1,23 @@
+{
+  "files.exclude": {
+    ".git/": true,
+    "node_modules/": true,
+    "dist/": true
+  },
+  "search.exclude": {
+    "**/node_modules": true,
+    "**/dist": true
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "eslint.validate": ["javascript", "typescript"],
+  "editor.rulers": [80],
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.tabSize": 2,
+  "editor.formatOnSave": true,
+  "[json]": {
+    "editor.formatOnSave": false
+  },
+  "typescript.tsdk": "./node_modules/typescript/lib"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Artsy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @artsy/dismissible
+
+A package that stores dismissible key/value entries in localStorage, which can be used in apps that require progressive onboarding and the like.
+
+## Use
+
+TODO
+
+## Commands
+
+```bash
+yarn test
+yarn type-check
+yarn lint
+yarn compile
+yarn watch
+```

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDismissibleContext = exports.DismissibleProvider = void 0;
+var DismissibleContext_1 = require("./DismissibleContext");
+Object.defineProperty(exports, "DismissibleProvider", { enumerable: true, get: function () { return DismissibleContext_1.DismissibleProvider; } });
+Object.defineProperty(exports, "useDismissibleContext", { enumerable: true, get: function () { return DismissibleContext_1.useDismissibleContext; } });
+//# sourceMappingURL=index.js.map

package/jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  moduleDirectories: ["node_modules", "src"],
+  preset: "ts-jest",
+  rootDir: "src",
+  testEnvironment: "jest-environment-jsdom",
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@artsy/dismissible",
+  "version": "0.1.0",
+  "private": false,
+  "main": "dist/index.js",
+  "license": "MIT",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "compile": "tsc --project tsconfig.build.json",
+    "lint": "eslint --cache --ext ts,tsx  --ignore-pattern 'dist'",
+    "prepare": "husky install",
+    "prepublish": "yarn compile",
+    "release": "auto shipit",
+    "test": "jest",
+    "type-check": "tsc --noEmit --pretty",
+    "watch": "tsc -p . --watch"
+  },
+  "devDependencies": {
+    "@artsy/auto-config": "^1.2.0",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@types/jest": "^29.1.2",
+    "@types/lodash.uniqby": "^4.7.9",
+    "@types/react": "^18.2.45",
+    "@typescript-eslint/eslint-plugin": "^5.40.0",
+    "@typescript-eslint/parser": "^5.40.0",
+    "auto": "^10.37.6",
+    "eslint": "^8.25.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^7.0.4",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "lint-staged": "11",
+    "prettier": "^2.7.1",
+    "pull-lock": "^1.0.0",
+    "react": "^18.2.0",
+    "react-test-renderer": "^18.2.0",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.8.3"
+  },
+  "pull-lock": {
+    "yarn.lock": "yarn install"
+  },
+  "dependencies": {
+    "lodash.uniqby": "^4.7.0",
+    "yup": "^1.3.3"
+  }
+}

package/src/DismissibleContext.tsx

@@ -0,0 +1,238 @@
+import * as Yup from "yup"
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useState,
+} from "react"
+import uniqBy from "lodash.uniqby"
+
+export type DismissibleKey = DismissibleContextProps["keys"][number]
+export type DismissibleKeys = DismissibleKey[]
+
+interface DismissedKey {
+  key: DismissibleKey
+  timestamp: number
+}
+
+interface DismissedKeyStatus {
+  status: boolean
+  timestamp: number
+}
+
+export interface DismissibleContextProps {
+  dismissed: DismissedKey[]
+  dismiss: (key: DismissibleKey | readonly DismissibleKey[]) => void
+  isDismissed: (key: DismissibleKey) => DismissedKeyStatus
+  keys: string[]
+  syncFromLoggedOutUser: () => void
+  /** An optional userID to track against  */
+  userID?: string | null
+  __internal__: ReturnType<typeof useLocalStorageUtils>
+}
+
+export const DismissibleContext = createContext<DismissibleContextProps>({
+  dismissed: [],
+  keys: [],
+  isDismissed: () => ({ status: false, timestamp: 0 }),
+} as unknown as DismissibleContextProps)
+
+export const DismissibleProvider: React.FC<{
+  children: React.ReactNode
+  keys: DismissibleKeys
+  userID?: DismissibleContextProps["userID"]
+}> = ({ children, keys = [], userID }) => {
+  const id = userID ?? PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID
+
+  const [dismissed, setDismissed] = useState<DismissedKey[]>([])
+
+  const localStorageUtils = useLocalStorageUtils({ keys })
+  const { __dismiss__, get } = localStorageUtils
+
+  const dismiss = useCallback(
+    (key: DismissibleKey | DismissibleKey[]) => {
+      const keys = Array.isArray(key) ? key : [key]
+      const timestamp = Date.now()
+
+      __dismiss__(id, timestamp, keys)
+
+      setDismissed((prevDismissed) => {
+        return uniqBy(
+          [...prevDismissed, ...keys.map((k) => ({ key: k, timestamp }))],
+          (d) => d.key
+        )
+      })
+    },
+    [id]
+  )
+
+  useEffect(() => {
+    setDismissed(get(id))
+  }, [id])
+
+  const mounted = useDidMount()
+
+  const isDismissed = useCallback(
+    (key: DismissibleKey) => {
+      if (!mounted) {
+        return {
+          status: false,
+          timestamp: 0,
+        }
+      }
+
+      const dismissedKey = dismissed.find((d) => d.key === key)
+
+      return dismissedKey
+        ? { status: true, timestamp: dismissedKey.timestamp }
+        : { status: false, timestamp: 0 }
+    },
+    [dismissed, mounted]
+  )
+
+  /**
+   * If the user is logged out, and performs some action which causes them
+   * to login, we need to sync up the dismissed state from the logged out user
+   */
+  const syncFromLoggedOutUser = useCallback(() => {
+    if (id === PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID) {
+      return
+    }
+
+    const loggedOutDismissals = get(PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID)
+    const loggedInDismissals = get(id)
+
+    const dismissals = uniqBy(
+      [...loggedOutDismissals, ...loggedInDismissals],
+      (d) => d.key
+    )
+
+    setDismissed(dismissals)
+
+    localStorage.setItem(localStorageKey(id), JSON.stringify(dismissals))
+    localStorage.removeItem(
+      localStorageKey(PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID)
+    )
+  }, [id])
+
+  // Ensure that the dismissed state stays in sync incase the user
+  // has multiple tabs open.
+  useEffect(() => {
+    const current = get(id)
+
+    if (current.length === 0) return
+
+    const handleFocus = () => {
+      setDismissed(current)
+    }
+
+    window.addEventListener("focus", handleFocus)
+
+    return () => {
+      window.removeEventListener("focus", handleFocus)
+    }
+  }, [id])
+
+  return (
+    <DismissibleContext.Provider
+      value={{
+        dismissed,
+        dismiss,
+        isDismissed,
+        keys,
+        syncFromLoggedOutUser,
+        __internal__: localStorageUtils,
+      }}
+    >
+      {children}
+    </DismissibleContext.Provider>
+  )
+}
+
+export const useDismissibleContext = () => {
+  return useContext(DismissibleContext)
+}
+
+export const PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID = "user" as const
+
+export const localStorageKey = (id: string) => {
+  return `progressive-onboarding.dismissed.${id}`
+}
+
+interface UseLocalStorageUtilsProps {
+  keys: DismissibleContextProps["keys"]
+}
+
+export const useLocalStorageUtils = ({ keys }: UseLocalStorageUtilsProps) => {
+  const schema = Yup.object().shape({
+    key: Yup.string().oneOf([...keys]),
+    timestamp: Yup.number(),
+  })
+
+  const isValid = (value: DismissedKey): value is DismissedKey => {
+    return schema.isValidSync(value)
+  }
+
+  const parse = (value: string | null): DismissedKey[] => {
+    if (!value) return []
+
+    try {
+      const parsed = JSON.parse(value)
+
+      return parsed.filter((obj: DismissedKey) => {
+        return isValid(obj) && keys.includes(obj.key)
+      })
+    } catch (err) {
+      return []
+    }
+  }
+
+  const __dismiss__ = (
+    id: string,
+    timestamp: number,
+    key: DismissibleKey | DismissibleKey[]
+  ) => {
+    const keys = Array.isArray(key) ? key : [key]
+
+    keys.forEach((key) => {
+      const item = localStorage.getItem(localStorageKey(id))
+      const dismissed = parse(item)
+
+      localStorage.setItem(
+        localStorageKey(id),
+        JSON.stringify(
+          uniqBy([...dismissed, { key, timestamp }], ({ key }) => key)
+        )
+      )
+    })
+  }
+
+  const get = (id: string) => {
+    const item = localStorage.getItem(localStorageKey(id))
+    return parse(item)
+  }
+
+  const reset = (id: string) => {
+    localStorage.removeItem(localStorageKey(id))
+  }
+
+  return {
+    __dismiss__,
+    get,
+    isValid,
+    parse,
+    reset,
+    schema,
+  }
+}
+
+function useDidMount(defaultMounted = false) {
+  const [isMounted, toggleMounted] = useState(defaultMounted)
+
+  useEffect(() => {
+    toggleMounted(true)
+  }, [])
+
+  return isMounted
+}

package/src/__tests__/DismissibleContext.jest.tsx

@@ -0,0 +1,261 @@
+import React from "react"
+import { renderHook } from "@testing-library/react-hooks"
+import {
+  PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID,
+  DismissibleProvider,
+  useLocalStorageUtils,
+  useDismissibleContext,
+  localStorageKey,
+} from "../DismissibleContext"
+
+describe("DismissibleContext", () => {
+  const keys = ["follow-artist", "follow-find", "follow-highlight"]
+  const id = "example-id"
+
+  const { get, reset, parse, __dismiss__ } = useLocalStorageUtils({
+    keys,
+  })
+
+  describe("get", () => {
+    afterEach(() => reset(id))
+
+    it("returns an empty array if there is no value in local storage", () => {
+      expect(get(id)).toEqual([])
+    })
+
+    it("returns empty array for the old format", () => {
+      localStorage.setItem(
+        localStorageKey(id),
+        JSON.stringify(["follow-artist"])
+      )
+      expect(get(id)).toEqual([])
+
+      localStorage.setItem(
+        localStorageKey(id),
+        JSON.stringify(["follow-artist", "follow-find"])
+      )
+      expect(get(id)).toEqual([])
+    })
+
+    it("returns the all dismissed keys if there is a value in local storage", () => {
+      __dismiss__(id, 999, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 999 }])
+      __dismiss__(id, 444, "follow-find")
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: 999 },
+        { key: "follow-find", timestamp: 444 },
+      ])
+    })
+
+    it("does not return duplicate keys", () => {
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+    })
+  })
+
+  describe("parse", () => {
+    it("returns an empty array if the value is null", () => {
+      expect(parse(null)).toEqual([])
+    })
+
+    it("returns an empty array if the value is not an array", () => {
+      expect(parse("foo")).toEqual([])
+    })
+
+    it("returns an empty array if the value is an array of non-strings", () => {
+      expect(parse(JSON.stringify([1, 2, 3]))).toEqual([])
+    })
+
+    it("returns an empty array if the value is an array of strings that are not valid keys", () => {
+      expect(parse(JSON.stringify(["foo", "bar", "baz"]))).toEqual([])
+    })
+
+    it("returns an array of valid keys if the value is an array of strings that are valid keys", () => {
+      expect(
+        parse(
+          JSON.stringify([
+            { key: "follow-artist", timestamp: 555 },
+            { key: "follow-find", timestamp: 555 },
+            { key: "follow-highlight", timestamp: 555 },
+          ])
+        )
+      ).toEqual([
+        { key: "follow-artist", timestamp: 555 },
+        { key: "follow-find", timestamp: 555 },
+        { key: "follow-highlight", timestamp: 555 },
+      ])
+    })
+
+    it("returns only the valid keys", () => {
+      expect(
+        parse(
+          JSON.stringify([
+            { key: "follow-artist", timestamp: 555 },
+            { key: "follow-find", timestamp: 555 },
+            { key: "follow-highlight", timestamp: 555 },
+            "foo",
+            { key: "no", timestamp: 555 },
+            { key: "alert-create", timestamp: "wrong" },
+            "baz",
+            1,
+            2,
+            true,
+            false,
+            null,
+            undefined,
+          ])
+        )
+      ).toEqual([
+        { key: "follow-artist", timestamp: 555 },
+        { key: "follow-find", timestamp: 555 },
+        { key: "follow-highlight", timestamp: 555 },
+      ])
+    })
+  })
+
+  describe("__dismiss__", () => {
+    afterEach(() => reset(id))
+
+    it("adds the key to local storage", () => {
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+    })
+
+    it("adds multiple keys to local storage", () => {
+      __dismiss__(id, 555, ["follow-artist", "follow-find"])
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: 555 },
+        { key: "follow-find", timestamp: 555 },
+      ])
+    })
+
+    it("does not add duplicate keys to local storage", () => {
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+    })
+
+    it('handles subsequent calls to "dismiss"', () => {
+      __dismiss__(id, 555, "follow-artist")
+      expect(get(id)).toEqual([{ key: "follow-artist", timestamp: 555 }])
+      __dismiss__(id, 555, "follow-find")
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: 555 },
+        { key: "follow-find", timestamp: 555 },
+      ])
+      __dismiss__(id, 555, "follow-highlight")
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: 555 },
+        { key: "follow-find", timestamp: 555 },
+        { key: "follow-highlight", timestamp: 555 },
+      ])
+    })
+  })
+
+  describe("dismiss", () => {
+    afterEach(() => reset(id))
+
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <DismissibleProvider keys={keys} userID={id}>
+        {children}
+      </DismissibleProvider>
+    )
+
+    it("dismisses keys", () => {
+      const { result } = renderHook(useDismissibleContext, {
+        wrapper,
+      })
+
+      result.current.dismiss("follow-artist")
+
+      expect(result.current.isDismissed("follow-artist")).toEqual({
+        status: true,
+        timestamp: expect.any(Number),
+      })
+
+      expect(result.current.isDismissed("follow-find")).toEqual({
+        status: false,
+        timestamp: 0,
+      })
+
+      expect(result.current.isDismissed("follow-highlight")).toEqual({
+        status: false,
+        timestamp: 0,
+      })
+
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: expect.any(Number) },
+      ])
+
+      result.current.dismiss(["follow-find", "follow-highlight"])
+
+      expect(result.current.isDismissed("follow-artist")).toEqual({
+        status: true,
+        timestamp: expect.any(Number),
+      })
+      expect(result.current.isDismissed("follow-find")).toEqual({
+        status: true,
+        timestamp: expect.any(Number),
+      })
+      expect(result.current.isDismissed("follow-highlight")).toEqual({
+        status: true,
+        timestamp: expect.any(Number),
+      })
+
+      expect(get(id)).toEqual([
+        { key: "follow-artist", timestamp: expect.any(Number) },
+        { key: "follow-find", timestamp: expect.any(Number) },
+        { key: "follow-highlight", timestamp: expect.any(Number) },
+      ])
+    })
+  })
+
+  describe("syncFromLoggedOutUser", () => {
+    it("does nothing if the user is logged out", () => {
+      const { result } = renderHook(useDismissibleContext, {
+        wrapper: ({ children }: { children: React.ReactNode }) => (
+          <DismissibleProvider keys={keys} userID={id}>
+            {children}
+          </DismissibleProvider>
+        ),
+      })
+
+      result.current.syncFromLoggedOutUser()
+
+      expect(get(id)).toEqual([])
+    })
+
+    describe("logged in", () => {
+      it("syncs the dismissed state from the logged out user", () => {
+        const loggedOutUserId = PROGRESSIVE_ONBOARDING_LOGGED_OUT_USER_ID
+
+        const loggedOutDismissals = [
+          { key: "follow-artist", timestamp: 555 },
+          { key: "follow-find", timestamp: 555 },
+        ]
+
+        localStorage.setItem(
+          localStorageKey(loggedOutUserId),
+          JSON.stringify(loggedOutDismissals)
+        )
+
+        expect(get(id)).toEqual([])
+
+        const { result } = renderHook(useDismissibleContext, {
+          wrapper: ({ children }: { children: React.ReactNode }) => (
+            <DismissibleProvider keys={keys} userID={id}>
+              {children}
+            </DismissibleProvider>
+          ),
+        })
+
+        result.current.syncFromLoggedOutUser()
+
+        expect(get(id)).toEqual(loggedOutDismissals)
+      })
+    })
+  })
+})

package/src/index.ts

@@ -0,0 +1,4 @@
+export {
+  DismissibleProvider,
+  useDismissibleContext,
+} from "./DismissibleContext"

package/tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "src/**/__tests__/*"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "src",
+    "esModuleInterop": true,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "react",
+    "lib": ["ES6", "DOM", "ES2016", "ES2017"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "target": "ES6"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}