@hublo/sentinel 1.2.0-alpha.4 → 1.2.0-alpha.40

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   registerAdapters,
   resolve,
   setDefaultRunner
-} from "./chunk-6DBTDMSN.js";
+} from "./chunk-PBCVWRXM.js";
 export {
   BaseAdapter,
   all,

package/dist/roles/build/nest/toolchain.d.ts

@@ -0,0 +1,98 @@
+import { UserConfig, Plugin } from 'vite';
+export { Plugin, PluginOption, UserConfig, UserConfigExport, defineConfig, loadEnv, mergeConfig } from 'vite';
+export { A as Alias, D as DecoratorMetadataOptions, d as decoratorMetadata, t as tsconfigAliases } from '../../../tsconfig-aliases-Ce6axdJ4.js';
+
+/** A transformer as the target declares it, passed through to the config unchanged. */
+interface TransformerDeclaration {
+    name: string;
+    options?: Record<string, unknown>;
+}
+/** An asset as the target declares it, in `@nx/webpack`'s own shape. */
+interface AssetDeclaration {
+    glob: string;
+    /** Relative to the workspace root, as the target declares it. */
+    input: string;
+    /** Relative to the output directory. */
+    output: string;
+}
+
+interface NestServiceOptions {
+    /** The nx project name. Keys the dependency graph, and names the module in messages. */
+    project: string;
+    /** Absolute path to the module's directory, normally `__dirname`. */
+    root: string;
+    /** Absolute path to the workspace root. */
+    workspaceRoot: string;
+    /** Entry point, relative to `root`. */
+    entry?: string;
+    /**
+     * The tsconfig whose emit must be preserved, when the service uses neither conventional name.
+     *
+     * Relative to `root`. Defaults to `tsconfig.app.json`, then `tsconfig.json`.
+     */
+    tsconfig?: string;
+    /** Output directory, relative to `workspaceRoot`. */
+    outDir?: string;
+    /**
+     * TypeScript transformers this service compiles with, as its build target declared them.
+     *
+     * Read off the webpack target by `--init` and written here, never inferred: what a service
+     * compiles with is the service's own. Eight services and BFFs run `@nestjs/swagger/plugin`,
+     * which writes the `@ApiProperty` decorators their DTOs do not declare by hand. Building
+     * without it succeeds and silently costs them most of their published contract (measured on
+     * `institution`: 385 insertions, 1378 deletions in the committed OpenAPI document).
+     */
+    transformers?: readonly TransformerDeclaration[];
+    /**
+     * Files copied into the output beside the bundle, in the shape `@nx/webpack` declared them.
+     *
+     * One service here uses it: `planning-period` ships the pug, css and ttf templates it renders
+     * printed documents from. Without them the service starts and fails on its first print.
+     */
+    assets?: readonly AssetDeclaration[];
+    /**
+     * Anything this service needs that the shape does not give it.
+     *
+     * Merged with Vite's own `mergeConfig`, never with a merge of our own: plugins concatenate
+     * and aliases stack the way Vite does it everywhere else, so there is no second set of
+     * semantics to learn or to document.
+     */
+    overrides?: UserConfig;
+}
+declare const nestService: (options: NestServiceOptions) => UserConfig;
+
+interface NodeManifestOptions {
+    /** The nx project name, which is how the graph is keyed. */
+    project: string;
+    /** Absolute path to the workspace root. */
+    workspaceRoot: string;
+    /** Where the bundle is written; the two files land beside it. */
+    outDir: string;
+    /** Entry file name, written as `main` so `node .` resolves inside the image. */
+    entry?: string;
+    /**
+     * Packages the IMAGE provides, which are therefore allowed to be required without being
+     * declared in the manifest.
+     *
+     * The generated Prisma clients are the case this exists for: the Dockerfile copies
+     * `node_modules/@prisma` from its own stage, so they resolve at runtime while no module
+     * declares them. Everything else that is required and undeclared is a bug, and the check
+     * below refuses the build.
+     */
+    providedByImage?: readonly string[];
+}
+/**
+ * Writes the manifest and lockfile once the bundle is on disk.
+ *
+ * `closeBundle` rather than `writeBundle`, so the files land after Vite has finished with the
+ * directory and cannot be cleared by `emptyOutDir`.
+ *
+ * `closeBundle` also runs after a FAILED build, where there is no directory to write into. Left
+ * alone this hook then threw `ENOENT` on the manifest, and since it is the last error raised it
+ * became the one Vite printed, hiding the failure that actually stopped the build. It cost two
+ * diagnoses before being recognised, so the missing directory is now read as what it is: the
+ * bundle was never written, and this plugin has nothing to say about why.
+ */
+declare const nodeManifest: (options: NodeManifestOptions) => Plugin;
+
+export { type NestServiceOptions, type NodeManifestOptions, nestService, nodeManifest };

package/dist/roles/build/nest/toolchain.js

@@ -0,0 +1,235 @@
+import {
+  decoratorMetadata,
+  tsconfigAliases
+} from "../../../chunk-3TDUIKVQ.js";
+
+// src/roles/build/nest/nest-service.ts
+import { join as join3 } from "path";
+import { mergeConfig } from "vite";
+
+// src/roles/build/nest/copy-assets.ts
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { dirname, join, relative, sep } from "path";
+function globToRegExp(glob) {
+  let pattern = "";
+  for (let index = 0; index < glob.length; index++) {
+    const char = glob[index] ?? "";
+    if (char === "*") {
+      if (glob[index + 1] === "*") {
+        pattern += glob[index + 2] === "/" ? "(?:.*/)?" : ".*";
+        index += glob[index + 2] === "/" ? 2 : 1;
+      } else {
+        pattern += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "{") {
+      const close = glob.indexOf("}", index);
+      if (close === -1)
+        throw new Error(`sentinel build(nest): unbalanced \`{\` in asset glob ${glob}`);
+      const alternatives = glob.slice(index + 1, close).split(",");
+      pattern += `(?:${alternatives.map((one) => one.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})`;
+      index = close;
+      continue;
+    }
+    pattern += char.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${pattern}$`);
+}
+function filesUnder(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      if (statSync(full).isDirectory()) walk(full);
+      else found.push(relative(root, full).split(sep).join("/"));
+    }
+  };
+  walk(root);
+  return found;
+}
+function resolveAssets(options) {
+  const copies = [];
+  for (const asset of options.assets) {
+    const input = join(options.workspaceRoot, asset.input);
+    if (!existsSync(input)) {
+      throw new Error(
+        `sentinel build(nest): the build target declares an asset from \`${asset.input}\`, which does not exist. webpack copied it into the output, so the built service would be missing files it reads at runtime.`
+      );
+    }
+    const matcher = globToRegExp(asset.glob);
+    const matched = filesUnder(input).filter((file) => matcher.test(file));
+    if (matched.length === 0) {
+      throw new Error(
+        `sentinel build(nest): the asset glob \`${asset.glob}\` under \`${asset.input}\` matches no file. An entry that matches nothing is the same silent loss as no entry at all.`
+      );
+    }
+    for (const file of matched) {
+      copies.push({ from: join(input, file), to: join(options.outDir, asset.output, file) });
+    }
+  }
+  return copies;
+}
+var copyAssets = (options) => ({
+  name: "sentinel:copy-assets",
+  // After the bundle is written and the output directory has stopped being emptied.
+  closeBundle() {
+    for (const { from, to } of resolveAssets(options)) {
+      mkdirSync(dirname(to), { recursive: true });
+      cpSync(from, to);
+    }
+  }
+});
+
+// src/roles/build/nest/node-manifest.ts
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { isBuiltin } from "module";
+import { join as join2 } from "path";
+var DEFAULT_PROVIDED_BY_IMAGE = ["@prisma"];
+var externalPackages = (bundle) => {
+  const emitted = new Set(Object.keys(bundle));
+  const packages = /* @__PURE__ */ new Set();
+  for (const emittedFile of Object.values(bundle)) {
+    if (emittedFile.type !== "chunk") continue;
+    for (const imported of emittedFile.imports) {
+      if (emitted.has(imported)) continue;
+      if (imported.startsWith(".") || imported.startsWith("/")) continue;
+      if (isBuiltin(imported)) continue;
+      const parts = imported.split("/");
+      const name = imported.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+      if (name) packages.add(name);
+    }
+  }
+  return packages;
+};
+var nodeManifest = (options) => {
+  let required;
+  return {
+    name: "sentinel:node-manifest",
+    apply: "build",
+    generateBundle(_outputOptions, bundle) {
+      required = externalPackages(bundle);
+    },
+    async closeBundle() {
+      const entry = options.entry ?? "main.js";
+      if (!existsSync2(join2(options.outDir, entry))) return;
+      const { createProjectGraphAsync } = await import("nx/src/devkit-exports.js");
+      const { createPackageJson, createLockFile, getLockFileName } = await import("@nx/js");
+      const graph = await createProjectGraphAsync({ exitOnError: false });
+      const manifest = createPackageJson(options.project, graph, {
+        root: options.workspaceRoot,
+        isProduction: true
+      });
+      manifest.main = entry;
+      if (required === void 0) {
+        throw new Error(
+          `sentinel build(nest): the bundle was written but never inspected, so the manifest could not be checked against what it requires. Refusing to write one that might not install.`
+        );
+      }
+      assertManifestCovers(required, manifest, options);
+      writeFileSync(join2(options.outDir, "package.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+      writeFileSync(
+        join2(options.outDir, getLockFileName("pnpm")),
+        createLockFile(manifest, graph, "pnpm")
+      );
+    }
+  };
+};
+var assertManifestCovers = (required, manifest, options) => {
+  const declared = new Set(Object.keys(manifest.dependencies ?? {}));
+  const provided = options.providedByImage ?? DEFAULT_PROVIDED_BY_IMAGE;
+  const missing = [...required].filter((name) => !declared.has(name)).filter((name) => !provided.some((prefix) => name === prefix || name.startsWith(`${prefix}/`))).sort();
+  if (missing.length === 0) return;
+  throw new Error(
+    `sentinel build(nest): the bundle requires ${missing.length} package(s) the generated manifest does not declare, so the image would not install them: ${missing.join(", ")}. Either declare them in the module's package.json, inline them with \`ssr.noExternal\`, or list them in \`providedByImage\` if the Dockerfile copies them in.`
+  );
+};
+
+// src/roles/build/nest/nest-service.ts
+var baseConfig = (options) => {
+  const outDir = join3(options.workspaceRoot, options.outDir ?? `dist/${options.project}`);
+  const entry = join3(options.root, options.entry ?? "src/main.ts");
+  return {
+    plugins: [
+      decoratorMetadata({
+        root: options.root,
+        tsconfig: options.tsconfig,
+        transformers: options.transformers
+      }),
+      ...options.assets?.length ? [copyAssets({ workspaceRoot: options.workspaceRoot, outDir, assets: options.assets })] : [],
+      nodeManifest({
+        project: options.project,
+        workspaceRoot: options.workspaceRoot,
+        outDir
+      })
+    ],
+    resolve: { alias: tsconfigAliases(options.workspaceRoot) },
+    ssr: {
+      // `importHelpers: true` in the workspace tsconfig makes TypeScript emit `require("tslib")`
+      // for `__decorate` and `__metadata`, so every decorated file depends on it. Hoisted into
+      // one scope Rollup inlined it and nobody noticed; preserving modules left it external, and
+      // the manifest nx generates from the project graph does not list it, because no module
+      // DECLARES tslib. The image therefore did not install it and the service died on its first
+      // require, only in the image: locally and in CI the workspace root has tslib.
+      noExternal: ["tslib"]
+    },
+    build: {
+      // An SSR build targets Node and leaves real packages external, which is what
+      // `webpack-node-externals` did: the image installs them from the generated manifest.
+      ssr: entry,
+      outDir,
+      emptyOutDir: true,
+      sourcemap: true,
+      target: "node20",
+      // The bundle is read by humans when a stack trace points into it, and minifying a
+      // server bundle buys nothing: it is never downloaded.
+      minify: false,
+      rollupOptions: {
+        output: {
+          format: "cjs",
+          // One output file per source module, instead of hoisting everything into one scope.
+          //
+          // This is not a preference, it is the only shape that keeps the OpenAPI contract.
+          // Merging every module into one scope forces Rollup to rename duplicate class names,
+          // and `@nestjs/swagger` keys its schemas on `class.name`, so a renamed class silently
+          // becomes a renamed schema in the published API. Measured on `network`, which has two
+          // such collisions: single bundle renames `InvalidPermissionError` and
+          // `PermissionNotFoundError`; preserving modules renames nothing and reproduces the
+          // committed contract byte for byte.
+          //
+          // The cost is 4.5 MB across 2003 files against 2.9 MB in one, still well under
+          // webpack's 6.9 MB for the same service, so nothing regresses against what it replaces.
+          preserveModules: true,
+          // The image runs `./dist/main.js`, so the entry keeps that name at the root while
+          // every other module keeps its own path. Under `preserveModules` a plain string here
+          // would be applied to all of them, which numbers them (`main962.js`) and loses the
+          // entry.
+          entryFileNames: (chunk) => chunk.facadeModuleId === entry ? "main.js" : "[name].js"
+        },
+        // Nest registers metadata as an IMPORT SIDE EFFECT: a decorator writes into a catalog
+        // when its module loads, and nothing references that module afterwards. Rollup may
+        // drop such a module; webpack never did.
+        //
+        // Measured on the first migrated service this changes nothing, so it is insurance
+        // rather than a fix, and it is recorded as such rather than credited with the smaller
+        // bundle (that comes from barrel re-exports the service does not use).
+        treeshake: { moduleSideEffects: true }
+      }
+    }
+  };
+};
+var nestService = (options) => options.overrides === void 0 ? baseConfig(options) : mergeConfig(baseConfig(options), options.overrides);
+
+// src/roles/build/nest/toolchain.ts
+import { defineConfig, loadEnv, mergeConfig as mergeConfig2 } from "vite";
+export {
+  decoratorMetadata,
+  defineConfig,
+  loadEnv,
+  mergeConfig2 as mergeConfig,
+  nestService,
+  nodeManifest,
+  tsconfigAliases
+};
+//# sourceMappingURL=toolchain.js.map

package/dist/roles/test/nest/toolchain.d.ts

@@ -0,0 +1,17 @@
+import { ViteUserConfig } from 'vitest/config';
+export { ConfigEnv, TestUserConfig, ViteUserConfig, defineConfig, mergeConfig } from 'vitest/config';
+export { loadEnv } from 'vite';
+export { A as Alias, D as DecoratorMetadataOptions, d as decoratorMetadata, t as tsconfigAliases } from '../../../tsconfig-aliases-Ce6axdJ4.js';
+
+interface NestTestOptions {
+    /** The module's own directory: where its specs live and what its config is relative to. */
+    root: string;
+    /** The workspace root, which is where `tsconfig.base.json` and its path aliases are. */
+    workspaceRoot: string;
+    /** Merged over the base. For what a module genuinely needs to differ on, nothing else. */
+    overrides?: ViteUserConfig;
+}
+/** The config, with the module's own overrides merged over it. */
+declare function nestTestConfig(options: NestTestOptions): ViteUserConfig;
+
+export { type NestTestOptions, nestTestConfig };

package/dist/roles/test/nest/toolchain.js

@@ -0,0 +1,116 @@
+import {
+  decoratorMetadata,
+  tsconfigAliases
+} from "../../../chunk-3TDUIKVQ.js";
+
+// src/roles/test/nest/toolchain.ts
+import { defineConfig, mergeConfig } from "vitest/config";
+import { loadEnv } from "vite";
+
+// src/roles/test/nest/nest-test-config.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function vitestMockExtendedPath() {
+  try {
+    return fileURLToPath(import.meta.resolve("vitest-mock-extended"));
+  } catch {
+    try {
+      return createRequire(import.meta.url).resolve("vitest-mock-extended");
+    } catch {
+      return "vitest-mock-extended";
+    }
+  }
+}
+function axiosAlias(root) {
+  const manifest = join(root, "node_modules", "axios", "package.json");
+  return existsSync(manifest) ? [{ find: /^axios$/, replacement: dirname(manifest) }] : [];
+}
+function baseConfig(options) {
+  const { root, workspaceRoot } = options;
+  return {
+    /*
+     * Nest reads constructor parameter types from `emitDecoratorMetadata`, and esbuild does not
+     * emit it. Without this plugin every injected dependency arrives `undefined`, which surfaces
+     * far from its cause. It is the BUILD role's plugin, imported rather than reimplemented: it
+     * already carries the two compile modes copied from nx, and a second copy here would be a
+     * second thing to keep in step.
+     */
+    plugins: [decoratorMetadata({ root })],
+    resolve: {
+      alias: [
+        ...axiosAlias(root),
+        /*
+         * `jest-mock-extended` loads `@jest/globals`, which refuses to run outside jest. 2491
+         * files import it, 104 of them under `libs/` as SHARED helpers, so migrating those helpers
+         * breaks every module still on jest and leaving them breaks every module moved to Vitest.
+         * Old and new therefore do not cohabit on shared helpers, which would have killed the
+         * per-module plan.
+         *
+         * This one line removes the constraint: an unmigrated helper resolves to the Vitest fork
+         * inside an adopted module and keeps resolving to the jest one everywhere else.
+         * `vitest-mock-extended@5.1.1` is a fork of the same package and exports the same names.
+         *
+         * Measured on `mission`: failing suites went from 159 to 10.
+         */
+        { find: /^jest-mock-extended$/, replacement: vitestMockExtendedPath() },
+        ...tsconfigAliases(workspaceRoot)
+      ]
+    },
+    test: {
+      globals: true,
+      environment: "node",
+      root,
+      /*
+       * Both extensions, because jest ran both. `**\/*.spec.ts` alone read green while missing
+       * three `.test.ts` files and 23 tests, with nothing saying so: a counter does not compare to
+       * itself, it compares to the reference.
+       */
+      include: ["**/*.spec.ts", "**/*.test.ts"],
+      /*
+       * Kept, and it is not a performance knob. Nest registers metadata as an import SIDE EFFECT:
+       * a decorator writes into a catalog when its module loads. Sharing a module registry across
+       * files lets one suite see what another registered, and the failure appears in whichever
+       * file happens to run second.
+       */
+      isolate: true
+    }
+  };
+}
+function asAliasArray(alias) {
+  if (alias === void 0) return [];
+  if (Array.isArray(alias)) return alias;
+  return Object.entries(alias).map(([find, replacement]) => ({
+    find,
+    replacement
+  }));
+}
+function nestTestConfig(options) {
+  const base = baseConfig(options);
+  if (options.overrides === void 0) return base;
+  return {
+    ...base,
+    ...options.overrides,
+    plugins: [...base.plugins ?? [], ...options.overrides.plugins ?? []],
+    resolve: {
+      ...base.resolve,
+      ...options.overrides.resolve,
+      // The module's own aliases come AFTER sentinel's, so a module that needs to win can.
+      alias: [
+        ...asAliasArray(base.resolve?.alias),
+        ...asAliasArray(options.overrides.resolve?.alias)
+      ]
+    },
+    test: { ...base.test, ...options.overrides.test }
+  };
+}
+export {
+  decoratorMetadata,
+  defineConfig,
+  loadEnv,
+  mergeConfig,
+  nestTestConfig,
+  tsconfigAliases
+};
+//# sourceMappingURL=toolchain.js.map

package/dist/roles/test/react/toolchain.d.ts

@@ -0,0 +1,2 @@
+export { ConfigEnv, TestUserConfig, ViteUserConfig, defineConfig, mergeConfig } from 'vitest/config';
+export { loadEnv } from 'vite';

package/dist/roles/test/react/toolchain.js

@@ -0,0 +1,9 @@
+// src/roles/test/react/toolchain.ts
+import { defineConfig, mergeConfig } from "vitest/config";
+import { loadEnv } from "vite";
+export {
+  defineConfig,
+  loadEnv,
+  mergeConfig
+};
+//# sourceMappingURL=toolchain.js.map

package/dist/roles/test/setup/msw-server.d.ts

@@ -0,0 +1,15 @@
+import * as msw_node from 'msw/node';
+
+/**
+ * No default handlers, deliberately.
+ *
+ * The repo's own server had `defaultHandlers = []` too, so nothing is lost. A handler here would
+ * be a Hublo endpoint inside a package meant to be usable by anyone, which is the line between
+ * what sentinel owns (the config) and what an app owns (what it mocks).
+ *
+ * A suite adds its own with `server.use(...)`, which is how all 600 files that touch this already
+ * work.
+ */
+declare const server: msw_node.SetupServer;
+
+export { server };

package/dist/roles/test/setup/msw-server.js

@@ -0,0 +1,7 @@
+import {
+  server
+} from "../../../chunk-NKFGYPIQ.js";
+export {
+  server
+};
+//# sourceMappingURL=msw-server.js.map

package/dist/roles/test/setup/nest.d.ts

@@ -0,0 +1,2 @@
+export { server } from './msw-server.js';
+import 'msw/node';

package/dist/roles/test/setup/nest.js

@@ -0,0 +1,47 @@
+import {
+  installMswLifecycle,
+  server
+} from "../../../chunk-NKFGYPIQ.js";
+
+// src/roles/test/setup/nest.ts
+import { afterAll, afterEach, beforeAll } from "vitest";
+
+// src/roles/test/setup/workspace.ts
+function isMissingModule(error) {
+  return error?.code === "ERR_MODULE_NOT_FOUND";
+}
+async function optional(specifier, use) {
+  try {
+    use(await import(
+      /* @vite-ignore */
+      specifier
+    ));
+  } catch (error) {
+    if (!isMissingModule(error)) throw error;
+  }
+}
+async function loadEnvironment() {
+  await optional("dotenv-flow", (module) => {
+    const flow = module;
+    const config = flow.config ?? flow.default?.config;
+    config?.({ silent: true, purge_dotenv: true });
+  });
+}
+async function pinLuxonZone() {
+  await optional("luxon", (module) => {
+    const settings = module.Settings;
+    if (settings) settings.defaultZone = "utc";
+  });
+}
+async function installWorkspaceSetup() {
+  await loadEnvironment();
+  await pinLuxonZone();
+}
+
+// src/roles/test/setup/nest.ts
+installMswLifecycle({ beforeAll, afterEach, afterAll });
+await installWorkspaceSetup();
+export {
+  server
+};
+//# sourceMappingURL=nest.js.map

package/dist/tsconfig-aliases-Ce6axdJ4.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from 'vite';
+
+/** A TypeScript transformer a service runs at build time, as its build target declares it. */
+interface TransformerDeclaration {
+    /** The package to load it from, e.g. `@nestjs/swagger/plugin`. */
+    name: string;
+    /** Passed to the transformer's own factory, unread here. */
+    options?: Record<string, unknown>;
+}
+interface DecoratorMetadataOptions {
+    /** The module being built. Its tsconfig is the one whose emit must be preserved. */
+    root: string;
+    /**
+     * An explicit tsconfig, when the service does not use either conventional name.
+     *
+     * Relative paths resolve against `root`.
+     */
+    tsconfig?: string;
+    /** The transformers this service declared, translated from its webpack target. */
+    transformers?: readonly TransformerDeclaration[];
+}
+declare const decoratorMetadata: (options: DecoratorMetadataOptions) => Plugin;
+
+interface Alias {
+    find: RegExp;
+    replacement: string;
+}
+/**
+ * Read the mappings from the workspace's base tsconfig.
+ *
+ * Longest pattern first, because Vite takes the first alias that matches and the mappings
+ * overlap by design: `@front/theme/node` must not be swallowed by `@front/theme`.
+ */
+declare const tsconfigAliases: (workspaceRoot: string, file?: string) => Alias[];
+
+export { type Alias as A, type DecoratorMetadataOptions as D, decoratorMetadata as d, tsconfigAliases as t };

package/lint/react-lib.json

@@ -58,6 +58,7 @@
       "all"
     ],
     "for-direction": "error",
+    "hublo/no-regex-lookbehind": "error",
     "jest-dom/prefer-checked": "error",
     "jest-dom/prefer-empty": "error",
     "jest-dom/prefer-enabled-disabled": "error",
@@ -348,7 +349,8 @@
     {
       "name": "storybook",
       "specifier": "eslint-plugin-storybook"
-    }
+    },
+    "../plugins/hublo.js"
   ],
   "overrides": [
     {

package/lint/react.json

@@ -58,6 +58,8 @@
       "all"
     ],
     "for-direction": "error",
+    "hublo/no-palette-common": "off",
+    "hublo/no-regex-lookbehind": "error",
     "jest/expect-expect": "off",
     "jest/no-alias-methods": "off",
     "jest/no-commented-out-tests": "off",
@@ -469,6 +471,7 @@
     {
       "name": "react-refresh",
       "specifier": "eslint-plugin-react-refresh"
-    }
+    },
+    "../plugins/hublo.js"
   ]
 }