@forsakringskassan/vite-lib-config 4.7.2 → 4.8.0

package/README.md

@@ -6,9 +6,16 @@ Toolchain for building Vue framework libraries.
 - Transpiled with Babel.
 - Supports monorepo.
 - Optional: build pageobjects and selectors.
+- Optional: shared typescript configuration.
 
 ## Configuration
 
+Use `fk-write-config` to write boilerplate configuration files to the repository:
+
+    fk-write-config
+
+By default it assumes `vitest` is used as test runner, use `--with-jest` or `--with-vitest` to explicitly set a test runner.
+
 ### Bundled dependencies
 
 By default all dependencies (`dependencies` and `peerDependencies`) are marked as external and not bundled in output files.

package/bin/write-config.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { run } from "../dist/write-config.mjs";
+
+const cwd = process.cwd();
+const argv = process.argv.slice(2);
+
+try {
+    await run(cwd, argv);
+} catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+}

package/dist/build-selectors.mjs

@@ -10,6 +10,7 @@ var extension = {
 async function build2(entrypoint, options) {
   const { external, formats } = options;
   if (!existsSync(entrypoint)) {
+    console.log(entrypoint, "does not exist, skipping");
     return;
   }
   const basename = path.basename(path.dirname(entrypoint));

package/dist/write-config.mjs

@@ -0,0 +1,663 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/p-locate/node_modules/yocto-queue/index.js
+var Node, Queue;
+var init_yocto_queue = __esm({
+  "node_modules/p-locate/node_modules/yocto-queue/index.js"() {
+    Node = class {
+      value;
+      next;
+      constructor(value) {
+        this.value = value;
+      }
+    };
+    Queue = class {
+      #head;
+      #tail;
+      #size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this.#head) {
+          this.#tail.next = node;
+          this.#tail = node;
+        } else {
+          this.#head = node;
+          this.#tail = node;
+        }
+        this.#size++;
+      }
+      dequeue() {
+        const current = this.#head;
+        if (!current) {
+          return;
+        }
+        this.#head = this.#head.next;
+        this.#size--;
+        if (!this.#head) {
+          this.#tail = void 0;
+        }
+        return current.value;
+      }
+      peek() {
+        if (!this.#head) {
+          return;
+        }
+        return this.#head.value;
+      }
+      clear() {
+        this.#head = void 0;
+        this.#tail = void 0;
+        this.#size = 0;
+      }
+      get size() {
+        return this.#size;
+      }
+      *[Symbol.iterator]() {
+        let current = this.#head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+      *drain() {
+        while (this.#head) {
+          yield this.dequeue();
+        }
+      }
+    };
+  }
+});
+
+// node_modules/p-locate/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run2 = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run2.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+var init_p_limit = __esm({
+  "node_modules/p-locate/node_modules/p-limit/index.js"() {
+    init_yocto_queue();
+  }
+});
+
+// node_modules/p-locate/index.js
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+var EndError, testElement, finder;
+var init_p_locate = __esm({
+  "node_modules/p-locate/index.js"() {
+    init_p_limit();
+    EndError = class extends Error {
+      constructor(value) {
+        super();
+        this.value = value;
+      }
+    };
+    testElement = async (element, tester) => tester(await element);
+    finder = async (element) => {
+      const values = await Promise.all(element);
+      if (values[1] === true) {
+        throw new EndError(values[0]);
+      }
+      return false;
+    };
+  }
+});
+
+// node_modules/locate-path/index.js
+import process from "node:process";
+import path from "node:path";
+import fs, { promises as fsPromises } from "node:fs";
+import { fileURLToPath } from "node:url";
+function checkType(type) {
+  if (type === "both" || Object.hasOwn(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+async function locatePath(paths, {
+  cwd = process.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+function locatePathSync(paths, {
+  cwd = process.cwd(),
+  type = "file",
+  allowSymlinks = true
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fs.statSync : fs.lstatSync;
+  for (const path_ of paths) {
+    try {
+      const stat = statFunction(path.resolve(cwd, path_), {
+        throwIfNoEntry: false
+      });
+      if (!stat) {
+        continue;
+      }
+      if (matchType(type, stat)) {
+        return path_;
+      }
+    } catch {
+    }
+  }
+}
+var typeMappings, matchType, toPath;
+var init_locate_path = __esm({
+  "node_modules/locate-path/index.js"() {
+    init_p_locate();
+    typeMappings = {
+      directory: "isDirectory",
+      file: "isFile"
+    };
+    matchType = (type, stat) => type === "both" ? stat.isFile() || stat.isDirectory() : stat[typeMappings[type]]();
+    toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+  }
+});
+
+// node_modules/unicorn-magic/default.js
+var init_default = __esm({
+  "node_modules/unicorn-magic/default.js"() {
+  }
+});
+
+// node_modules/unicorn-magic/node.js
+import { promisify } from "node:util";
+import { execFile as execFileCallback, execFileSync as execFileSyncOriginal } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function toPath2(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+}
+var execFileOriginal, TEN_MEGABYTES_IN_BYTES;
+var init_node = __esm({
+  "node_modules/unicorn-magic/node.js"() {
+    init_default();
+    execFileOriginal = promisify(execFileCallback);
+    TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
+  }
+});
+
+// node_modules/find-up/index.js
+var find_up_exports = {};
+__export(find_up_exports, {
+  findDown: () => findDown,
+  findDownSync: () => findDownSync,
+  findUp: () => findUp,
+  findUpMultiple: () => findUpMultiple,
+  findUpMultipleSync: () => findUpMultipleSync,
+  findUpStop: () => findUpStop,
+  findUpSync: () => findUpSync
+});
+import path2 from "node:path";
+import fs2 from "node:fs";
+async function findUpMultiple(name, options = {}) {
+  let directory = path2.resolve(toPath2(options.cwd) ?? "");
+  const { root } = path2.parse(directory);
+  const stopAt = path2.resolve(directory, toPath2(options.stopAt) ?? root);
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2.dirname(directory);
+  }
+  return matches;
+}
+function findUpMultipleSync(name, options = {}) {
+  let directory = path2.resolve(toPath2(options.cwd) ?? "");
+  const { root } = path2.parse(directory);
+  const stopAt = path2.resolve(directory, toPath2(options.stopAt) ?? root);
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePathSync(paths, locateOptions);
+    }
+    const foundPath = name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePathSync([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+function findUpSync(name, options = {}) {
+  const matches = findUpMultipleSync(name, { ...options, limit: 1 });
+  return matches[0];
+}
+async function findDownDepthFirst(directory, paths, maxDepth, locateOptions, currentDepth = 0) {
+  const found = await locatePath(paths, { cwd: directory, ...locateOptions });
+  if (found) {
+    return path2.resolve(directory, found);
+  }
+  if (currentDepth >= maxDepth) {
+    return void 0;
+  }
+  try {
+    const entries = await fs2.promises.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const result = await findDownDepthFirst(
+          path2.join(directory, entry.name),
+          paths,
+          maxDepth,
+          locateOptions,
+          currentDepth + 1
+        );
+        if (result) {
+          return result;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function findDownDepthFirstSync(directory, paths, maxDepth, locateOptions, currentDepth = 0) {
+  const found = locatePathSync(paths, { cwd: directory, ...locateOptions });
+  if (found) {
+    return path2.resolve(directory, found);
+  }
+  if (currentDepth >= maxDepth) {
+    return void 0;
+  }
+  try {
+    const entries = fs2.readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const result = findDownDepthFirstSync(
+          path2.join(directory, entry.name),
+          paths,
+          maxDepth,
+          locateOptions,
+          currentDepth + 1
+        );
+        if (result) {
+          return result;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function prepareFindDownOptions(name, options) {
+  const startDirectory = path2.resolve(toPath2(options.cwd) ?? "");
+  const maxDepth = Math.max(0, options.depth ?? 1);
+  const paths = [name].flat();
+  const { type = "file", allowSymlinks = true, strategy = "breadth" } = options;
+  const locateOptions = { type, allowSymlinks };
+  return {
+    startDirectory,
+    maxDepth,
+    paths,
+    locateOptions,
+    strategy
+  };
+}
+async function findDownBreadthFirst(startDirectory, paths, maxDepth, locateOptions) {
+  const queue = [{ directory: startDirectory, depth: 0 }];
+  while (queue.length > 0) {
+    const { directory, depth } = queue.shift();
+    const found = await locatePath(paths, { cwd: directory, ...locateOptions });
+    if (found) {
+      return path2.resolve(directory, found);
+    }
+    if (depth >= maxDepth) {
+      continue;
+    }
+    try {
+      const entries = await fs2.promises.readdir(directory, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          queue.push({ directory: path2.join(directory, entry.name), depth: depth + 1 });
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function findDownBreadthFirstSync(startDirectory, paths, maxDepth, locateOptions) {
+  const queue = [{ directory: startDirectory, depth: 0 }];
+  while (queue.length > 0) {
+    const { directory, depth } = queue.shift();
+    const found = locatePathSync(paths, { cwd: directory, ...locateOptions });
+    if (found) {
+      return path2.resolve(directory, found);
+    }
+    if (depth >= maxDepth) {
+      continue;
+    }
+    try {
+      const entries = fs2.readdirSync(directory, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          queue.push({ directory: path2.join(directory, entry.name), depth: depth + 1 });
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function findDown(name, options = {}) {
+  const { startDirectory, maxDepth, paths, locateOptions, strategy } = prepareFindDownOptions(name, options);
+  return strategy === "depth" ? findDownDepthFirst(startDirectory, paths, maxDepth, locateOptions) : findDownBreadthFirst(startDirectory, paths, maxDepth, locateOptions);
+}
+function findDownSync(name, options = {}) {
+  const { startDirectory, maxDepth, paths, locateOptions, strategy } = prepareFindDownOptions(name, options);
+  return strategy === "depth" ? findDownDepthFirstSync(startDirectory, paths, maxDepth, locateOptions) : findDownBreadthFirstSync(startDirectory, paths, maxDepth, locateOptions);
+}
+var findUpStop;
+var init_find_up = __esm({
+  "node_modules/find-up/index.js"() {
+    init_locate_path();
+    init_node();
+    findUpStop = /* @__PURE__ */ Symbol("findUpStop");
+  }
+});
+
+// src/write-config.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+var boilerplate = `/* This file was generated by @forsakringskassan/vite-lib-config. Changes may be overwritten! */`;
+function detectTestRunner(flags) {
+  if (flags.has("--with-jest")) {
+    return "jest";
+  } else if (flags.has("--with-vitest")) {
+    return "vitest";
+  } else {
+    return "vitest";
+  }
+}
+async function serializeJson(data) {
+  const { format, resolveConfig } = await import("prettier");
+  const content = JSON.stringify(data, null, 4);
+  const filepath = "tsconfig.json";
+  const config = await resolveConfig(filepath, { editorconfig: true });
+  const formatted = await format(content, { ...config, filepath });
+  return formatted;
+}
+async function generateTsconfig(options) {
+  const { name, enablePageobjects, enableSelectors, testRunner } = options;
+  const config = {
+    extends: "@forsakringskassan/vite-lib-config/tsconfig.root.json",
+    compilerOptions: void 0,
+    include: void 0,
+    exclude: void 0,
+    references: [
+      { path: "./tsconfig.lib.json" },
+      { path: "./tsconfig.cypress.json" }
+    ]
+  };
+  if (testRunner === "jest") {
+    config.extends = [
+      "@forsakringskassan/vite-lib-config/tsconfig.root.json",
+      "@fkui/tsconfig/recommended",
+      "@fkui/tsconfig/vue"
+    ];
+    config.compilerOptions = {
+      declarationDir: "temp/jest",
+      paths: {
+        [name]: ["./src/index.ts"]
+      }
+    };
+    config.include = ["src/@types/*.ts"];
+    config.exclude = ["src/@types/cypress.d.ts"];
+  }
+  if (enablePageobjects) {
+    config.references?.push({ path: "./tsconfig.pageobjects.json" });
+  }
+  if (enableSelectors) {
+    config.references?.push({ path: "./tsconfig.selectors.json" });
+  }
+  return [boilerplate, await serializeJson(config)].join("\n\n");
+}
+async function generateTsconfigLib(options) {
+  const { name, testRunner } = options;
+  const config = {
+    extends: "@forsakringskassan/vite-lib-config/tsconfig.lib.json",
+    compilerOptions: {
+      types: testRunner === "jest" ? ["node", "jest", "vite/client"] : void 0,
+      paths: {
+        [`${name}/cypress`]: ["./src/cypress/index.ts"],
+        [`${name}/selectors`]: ["./src/selectors/index.ts"],
+        [name]: ["./src/index.ts"]
+      }
+    }
+  };
+  return [boilerplate, await serializeJson(config)].join("\n\n");
+}
+async function generateTsconfigCypress(options) {
+  const { name, cypressConfigPath } = options;
+  const config = {
+    extends: [
+      cypressConfigPath,
+      "@forsakringskassan/vite-lib-config/tsconfig.cypress.json"
+    ],
+    compilerOptions: {
+      paths: {
+        [`${name}/cypress`]: ["./src/cypress/index.ts"],
+        [`${name}/selectors`]: ["./src/selectors/index.ts"],
+        [name]: ["./src/index.ts"]
+      }
+    }
+  };
+  return [boilerplate, await serializeJson(config)].join("\n\n");
+}
+async function generateTsconfigSelectors(options) {
+  if (!options.enableSelectors) {
+    return null;
+  }
+  const config = {
+    extends: "@forsakringskassan/vite-lib-config/tsconfig.selectors.json"
+  };
+  return [boilerplate, await serializeJson(config)].join("\n\n");
+}
+async function generateTsconfigPageobjects(options) {
+  if (!options.enablePageobjects) {
+    return null;
+  }
+  const config = {
+    extends: "@forsakringskassan/vite-lib-config/tsconfig.pageobjects.json"
+  };
+  return [boilerplate, await serializeJson(config)].join("\n\n");
+}
+async function readJsonFile(filePath) {
+  const content = await fs3.readFile(filePath, "utf8");
+  return JSON.parse(content);
+}
+async function writeJsonFile(cwd, filename, content) {
+  const filePath = path3.join(cwd, filename);
+  await fs3.writeFile(filePath, content, "utf8");
+  console.log(filename, "written");
+}
+async function findCypressConfigPath(cwd) {
+  const { findUp: findUp2 } = await Promise.resolve().then(() => (init_find_up(), find_up_exports));
+  const absolutePath = await findUp2("cypress/tsconfig.json", { cwd });
+  if (absolutePath) {
+    return path3.relative(cwd, absolutePath).replaceAll("\\", "/");
+  }
+  return "cypress/tsconfig.json";
+}
+function isTSConfigFile(filename) {
+  return filename.startsWith("tsconfig.") && filename.endsWith(".json");
+}
+async function run(cwd, argv) {
+  const flags = new Set(argv.filter((it) => it.startsWith("--")));
+  if (flags.has("--help")) {
+    console.log("usage: fk-write-config [OPTIONS..]");
+    console.log(`
+  --help                     Show this help.
+  --with-jest                Use Jest as test runner.
+  --with-vitest              Use Vitest as test runner.
+`);
+    return;
+  }
+  const pkg = await readJsonFile(path3.join(cwd, "package.json"));
+  const cypressConfigPath = await findCypressConfigPath(cwd);
+  const testRunner = detectTestRunner(flags);
+  const options = {
+    name: pkg.name,
+    cypressConfigPath,
+    testRunner,
+    enablePageobjects: Boolean(pkg.exports?.["./cypress"]),
+    enableSelectors: Boolean(pkg.exports?.["./selectors"])
+  };
+  const generated = /* @__PURE__ */ new Map([
+    ["tsconfig.json", generateTsconfig(options)],
+    ["tsconfig.lib.json", generateTsconfigLib(options)],
+    ["tsconfig.cypress.json", generateTsconfigCypress(options)],
+    ["tsconfig.selectors.json", generateTsconfigSelectors(options)],
+    ["tsconfig.pageobjects.json", generateTsconfigPageobjects(options)]
+  ]);
+  console.group("Writing TypeScript configuration");
+  console.log("Test runner:", testRunner);
+  console.log();
+  const written = /* @__PURE__ */ new Set();
+  for (const [filename, promise] of generated.entries()) {
+    const content = await promise;
+    if (content) {
+      await writeJsonFile(cwd, filename, content);
+      written.add(filename);
+    }
+  }
+  const entries = await fs3.readdir(cwd);
+  for (const entry of entries) {
+    if (isTSConfigFile(entry) && !written.has(entry)) {
+      await fs3.unlink(path3.join(cwd, entry));
+      console.log(entry, "removed");
+    }
+  }
+  console.groupEnd();
+}
+export {
+  generateTsconfig,
+  generateTsconfigCypress,
+  generateTsconfigLib,
+  generateTsconfigPageobjects,
+  generateTsconfigSelectors,
+  run
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forsakringskassan/vite-lib-config",
-  "version": "4.7.2",
+  "version": "4.8.0",
   "description": "Försäkringskassan toolchain to build libraries with Vite",
   "keywords": [
     "vite"
@@ -18,29 +18,36 @@
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js"
     },
+    "./assets/*": "./assets/*",
     "./babel": {
       "types": "./dist/babel.config.d.ts",
       "require": "./dist/babel.config.js"
     },
+    "./tsconfig.root.json": "./tsconfig/tsconfig.root.json",
+    "./tsconfig.cypress.json": "./tsconfig/tsconfig.cypress.json",
+    "./tsconfig.lib.json": "./tsconfig/tsconfig.lib.json",
+    "./tsconfig.pageobjects.json": "./tsconfig/tsconfig.pageobjects.json",
+    "./tsconfig.selectors.json": "./tsconfig/tsconfig.selectors.json",
     "./vite": {
       "types": "./dist/vite.config.d.ts",
       "import": "./dist/vite.config.mjs",
       "require": "./dist/vite.config.cjs"
-    },
-    "./assets/*": "./assets/*"
+    }
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
     "fk-api-extractor": "bin/api-extractor.mjs",
     "fk-build-vue-lib": "bin/build-vue-lib.mjs",
-    "fk-build-selectors": "bin/build-selectors.mjs"
+    "fk-build-selectors": "bin/build-selectors.mjs",
+    "fk-write-config": "bin/write-config.mjs"
   },
   "files": [
     "*.d.ts",
     "assets",
     "bin",
-    "dist"
+    "dist",
+    "tsconfig"
   ],
   "dependencies": {
     "@microsoft/api-extractor": "7.58.7",
@@ -50,7 +57,9 @@
   "peerDependencies": {
     "@babel/core": "^7.22.0",
     "@babel/plugin-transform-nullish-coalescing-operator": "^7.22.0",
+    "@fkui/tsconfig": ">= 6.3.0",
     "@forsakringskassan/apimock-express": "^1.1.0 || ^2.0.0",
+    "prettier": "^3.0.0",
     "typescript": "^5.0.2 || ^6.0.2",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
     "vue": "^3.0.0"

package/tsconfig/README.md

@@ -0,0 +1 @@
+`tsconfig.json` files for usage in the consumer library.

package/tsconfig/tsconfig.cypress.json

@@ -0,0 +1,18 @@
+{
+    "$schema": "https://www.schemastore.org/tsconfig",
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "${configDir}/temp/tsconfig.cypress.tsbuildinfo",
+        "outDir": "${configDir}/temp",
+        "rootDir": "${configDir}/src",
+        "emitDeclarationOnly": true,
+        "declarationDir": "temp/cypress",
+        "skipLibCheck": true
+    },
+    "include": [
+        "${configDir}/src/**/*.ts",
+        "${configDir}/src/**/*.vue",
+        "${configDir}/src/**/*.cy.ts"
+    ],
+    "exclude": ["${configDir}/src/**/*.spec.ts"]
+}

package/tsconfig/tsconfig.lib.json

@@ -0,0 +1,16 @@
+{
+    "$schema": "https://www.schemastore.org/tsconfig",
+    "extends": ["@fkui/tsconfig/recommended", "@fkui/tsconfig/vue"],
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "${configDir}/temp/tsconfig.lib.tsbuildinfo",
+        "types": ["node", "vite/client"]
+    },
+    "include": ["${configDir}/src/**/*.ts", "${configDir}/src/**/*.vue"],
+    "exclude": [
+        "${configDir}/src/@types/cypress.d.ts",
+        "${configDir}/src/cypress/**/*.ts",
+        "${configDir}/src/**/*.cy.ts",
+        "${configDir}/src/**/*.pageobject.ts"
+    ]
+}

package/tsconfig/tsconfig.pageobjects.json

@@ -0,0 +1,16 @@
+{
+    "extends": "@fkui/tsconfig/recommended",
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "${configDir}/temp/tsconfig.pageobjects.tsbuildinfo",
+        "types": ["cypress"],
+        "emitDeclarationOnly": true,
+        "skipLibCheck": true
+    },
+    "include": [
+        "${configDir}/src/cypress/**/*.ts",
+        "${configDir}/src/selectors/**/*.ts",
+        "${configDir}/src/**/*.pageobject.ts"
+    ],
+    "exclude": ["${configDir}/src/**/*.cy.ts", "${configDir}/src/**/*.spec.ts"]
+}

package/tsconfig/tsconfig.root.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "tsBuildInfoFile": "${configDir}/temp/tsconfig.tsbuildinfo"
+    },
+    "files": [],
+    "references": [
+        {
+            "path": "${configDir}/tsconfig.lib.json"
+        },
+        {
+            "path": "${configDir}/tsconfig.pageobjects.json"
+        },
+        {
+            "path": "${configDir}/tsconfig.cypress.json"
+        },
+        {
+            "path": "${configDir}/tsconfig.selectors.json"
+        }
+    ]
+}

package/tsconfig/tsconfig.selectors.json

@@ -0,0 +1,11 @@
+{
+    "extends": "@fkui/tsconfig/recommended",
+    "compilerOptions": {
+        "composite": true,
+        "tsBuildInfoFile": "${configDir}/temp/tsconfig.selectors.tsbuildinfo",
+        "types": [],
+        "emitDeclarationOnly": true
+    },
+    "include": ["${configDir}/src/selectors/**/*.ts"],
+    "exclude": ["${configDir}/src/**/*.spec.ts"]
+}