skyltmax_config 3.0.1 → 4.0.0

data/reset.d.ts

@@ -1,6 +1,8 @@
-// `/dom` is the whole `recommended` set (filter-boolean, json-parse, is-array, includes/has/indexOf, promise-catch,
-// map-constructor) plus the Storage overrides — importing any of those entrypoints separately is a no-op.
-import "@total-typescript/ts-reset/dom"
+// Vendored ts-reset (the `/dom` set minus groupBy and promise-catch; see the header of ts-reset.d.ts). A path reference,
+// not an import, because it bypasses module resolution: under a consumer's `nodenext`, `import "./ts-reset"` resolves
+// to nothing without an error (this file is a library .d.ts), silently dropping every override.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./ts-reset.d.ts" />
 
 import "react"
 

data/tests/configs.test.js

@@ -39,7 +39,7 @@ const EXPECTED_ESLINT_PLUGINS = [
   "@typescript-eslint",
   "import",
   "jest-dom",
-  "jsx-a11y",
+  "jsx-a11y-x",
   "prettier",
   "react-hooks",
   "testing-library",

data/tests/reset.types.ts

@@ -0,0 +1,60 @@
+// Type-level checks for the vendored ts-reset in ts-reset.d.ts, loaded through reset.d.ts by tsconfig.json's `types`.
+// Nothing here runs: `pnpm typecheck` is the test, and a failing assertion is a compile error. Each line documents a
+// behaviour consumers of `@signmax/config/reset.d.ts` rely on, including the two entrypoints deliberately left out.
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
+type Expect<T extends true> = T
+
+declare const values: (string | number | null | undefined | 0 | "")[]
+declare const response: Response
+declare const literals: readonly ("a" | "b")[]
+declare const widened: string
+declare const anything: unknown
+declare const union: Promise<string> | Promise<number>
+declare const element: HTMLDivElement
+
+const _filtered = values.filter(Boolean)
+const _parsed = JSON.parse("{}")
+const _json = response.json()
+const _map = new Map()
+const _stored = localStorage.token
+const _cloned = element.cloneNode(true)
+
+export type Checks = [
+  // filter-boolean
+  Expect<Equal<typeof _filtered, (string | number)[]>>,
+  // json-parse, fetch
+  Expect<Equal<typeof _parsed, unknown>>,
+  Expect<Equal<typeof _json, Promise<unknown>>>,
+  // map-constructor
+  Expect<Equal<typeof _map, Map<unknown, unknown>>>,
+  // storage
+  Expect<Equal<typeof _stored, unknown>>,
+  // clone-node
+  Expect<Equal<typeof _cloned, HTMLDivElement>>,
+]
+
+// filter-boolean inline as an argument still checks the elements (ts-reset#233; 0.6.1 let this compile)
+declare function pet(animals: readonly { type: string; name: string }[]): void
+// @ts-expect-error — `{ type: "dog" }` is missing `name`
+pet([{ type: "cat", name: "Fluffy" }, { type: "dog" }].filter(Boolean))
+
+// array-includes: a widened value is accepted without a cast
+literals.includes(widened)
+
+// is-array narrows to unknown[], not any[]
+if (Array.isArray(anything)) {
+  const first: unknown = anything[0]
+  // @ts-expect-error — unknown is not assignable to string; under the stock lib this would be any and compile
+  const notAny: string = anything[0]
+  void [first, notAny]
+}
+
+// promise-catch is NOT vendored: `.catch` on a union of promises compiles (ts-reset#209 made it TS2349)
+void union.catch(() => undefined)
+
+// map-groupby / object-groupby are NOT vendored: the ES2022 target from typescript.json still rejects them
+// @ts-expect-error — TS2550, groupBy needs lib es2024
+void Map.groupBy([1], n => n)
+// @ts-expect-error — TS2550, groupBy needs lib es2024
+void Object.groupBy([1], n => n)

data/ts-reset.d.ts

@@ -0,0 +1,133 @@
+// Vendored from @total-typescript/ts-reset (https://github.com/mattpocock/ts-reset), `src/entrypoints/` at commit
+// 81b3b2614a32e47948cd4b8d5468879c07c2b361 — the unpublished 0.7.0 on `main`; npm `latest` is stuck at 0.6.1 because
+// the 2026-04-01 publish failed. This is the `/dom` entrypoint (`recommended` + `storage` + `clone-node`) minus:
+//
+// - `map-groupby` and `object-groupby`: they declare `Map.groupBy`/`Object.groupBy` outright, so under this config's
+//   ES2022 lib they typecheck instead of reporting TS2550 — they would widen the target check, not just refine a type.
+// - `promise-catch`, which 0.7.0 itself drops from `recommended`: its extra overload makes `.catch()`/`.then()` on a
+//   `Promise<A> | Promise<B>` union a hard TS2349 error (ts-reset#209).
+//
+// Must stay a global script (no top-level import/export): every declaration here merges into a lib interface.
+// docs/upgrades/INTERACTIONS.md §11 has the provenance and the way back to the package.
+//
+// Copyright 2023 Matthew Pocock
+//
+// 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.
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars --
+   these are merges into lib interfaces: signatures mirror the lib's `any`, and type parameters (`Map<K, V>`) must match
+   the lib's declarations exactly, used or not. */
+
+// --- utils ---
+declare namespace TSReset {
+  type NonFalsy<T> = T extends false | 0 | "" | null | undefined | 0n ? never : T
+
+  type WidenLiteral<T> = T extends string
+    ? string
+    : T extends number
+      ? number
+      : T extends boolean
+        ? boolean
+        : T extends bigint
+          ? bigint
+          : T extends symbol
+            ? symbol
+            : T
+}
+
+// --- fetch: `res.json()` returns unknown instead of any ---
+interface Body {
+  json(): Promise<unknown>
+}
+
+// --- filter-boolean: `.filter(Boolean)` removes falsy members from the element type ---
+// NoInfer<S> prevents contextual typing from flowing backward through S when .filter(Boolean) is used inline as a
+// function argument, which would silently skip structural checks on array elements (ts-reset#233). The <S extends T>
+// generic keeps overload resolution correct so non-Boolean predicates on union arrays fall through to the built-in.
+interface Array<T> {
+  filter<S extends T>(predicate: BooleanConstructor, thisArg?: any): TSReset.NonFalsy<NoInfer<S>>[]
+}
+
+interface ReadonlyArray<T> {
+  filter<S extends T>(predicate: BooleanConstructor, thisArg?: any): TSReset.NonFalsy<NoInfer<S>>[]
+}
+
+// --- is-array: `Array.isArray` narrows to unknown[] instead of any[] ---
+interface ArrayConstructor {
+  isArray(arg: any): arg is unknown[]
+}
+
+// --- json-parse: `JSON.parse` returns unknown instead of any ---
+interface JSON {
+  /**
+   * Converts a JavaScript Object Notation (JSON) string into an object.
+   * @param text A valid JSON string.
+   * @param reviver A function that transforms the results. This function is called for each member of the object.
+   * If a member contains nested objects, the nested objects are transformed before the parent object is.
+   */
+  parse(text: string, reviver?: (this: any, key: string, value: any) => any): unknown
+}
+
+// --- array-includes: `.includes` accepts the widened type of a literal-typed array ---
+interface ReadonlyArray<T> {
+  includes(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): boolean
+}
+
+interface Array<T> {
+  includes(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): boolean
+}
+
+// --- set-has ---
+interface Set<T> {
+  has(value: T | (TSReset.WidenLiteral<T> & {})): boolean
+}
+
+interface ReadonlySet<T> {
+  has(value: T | (TSReset.WidenLiteral<T> & {})): boolean
+}
+
+// --- map-constructor: `new Map()` is Map<unknown, unknown> instead of Map<any, any> ---
+interface MapConstructor {
+  new <K = unknown, V = unknown>(): Map<K, V>
+}
+
+// --- map-has ---
+interface Map<K, V> {
+  has(value: K | (TSReset.WidenLiteral<K> & {})): boolean
+}
+
+interface ReadonlyMap<K, V> {
+  has(value: K | (TSReset.WidenLiteral<K> & {})): boolean
+}
+
+// --- array-index-of ---
+interface ReadonlyArray<T> {
+  lastIndexOf(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): number
+  indexOf(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): number
+}
+
+interface Array<T> {
+  lastIndexOf(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): number
+  indexOf(searchElement: T | (TSReset.WidenLiteral<T> & {}), fromIndex?: number): number
+}
+
+// --- storage (dom): unknown keys on `localStorage`/`sessionStorage` read as unknown instead of any ---
+interface Storage {
+  [name: string & {}]: unknown
+}
+
+// --- clone-node (dom): `el.cloneNode()` keeps the element type instead of widening to Node ---
+interface Node {
+  cloneNode(subtree?: boolean): this
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skyltmax_config
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Signmax AB
@@ -109,6 +109,7 @@ files:
 - fixture/pnpm-lock.yaml
 - fixture/pnpm-workspace.yaml
 - fixture/src/index.ts
+- fixture/src/ui/avatar.tsx
 - fixture/src/ui/button.tsx
 - fixture/src/ui/card.tsx
 - fixture/tsconfig.json
@@ -125,6 +126,8 @@ files:
 - rubocop.yml
 - skyltmax_config.gemspec
 - tests/configs.test.js
+- tests/reset.types.ts
+- ts-reset.d.ts
 - tsconfig.json
 - typescript.json
 homepage: https://github.com/skyltmax/config