tsl-react 0.0.6 → 0.0.8

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { Rule } from "tsl";
+import * as tsl0 from "tsl";
 
 //#region src/rules/no-leaked-conditional-rendering.d.ts
-
 /**
  * Prevents problematic leaked values from being rendered.
  *
@@ -53,6 +52,6 @@ import { Rule } from "tsl";
  *
  * @since 0.0.0
  */
-declare const noLeakedConditionalRendering: (options?: "off" | undefined) => Rule<unknown>;
+declare const noLeakedConditionalRendering: (options?: "off" | undefined) => tsl0.Rule<unknown>;
 //#endregion
 export { noLeakedConditionalRendering };

package/dist/index.js

@@ -1,14 +1,509 @@
-import { compare } from "compare-versions";
-import { defineRule } from "tsl";
-import { SyntaxKind } from "typescript";
 import { unit } from "@let/eff";
 import { isLogicalNegationExpression } from "@react-analyzer/ast";
-import { getVariantsOfTypes } from "@react-analyzer/core";
 import { getAnalyzerOptions, report } from "@react-analyzer/shared";
+import { compare } from "compare-versions";
+import { defineRule } from "tsl";
+import ts, { SyntaxKind } from "typescript";
 
+//#region ../../../node_modules/.pnpm/ts-pattern@5.9.0/node_modules/ts-pattern/dist/index.js
+const t = Symbol.for("@ts-pattern/matcher"), e = Symbol.for("@ts-pattern/isVariadic"), n = "@ts-pattern/anonymous-select-key", r = (t) => Boolean(t && "object" == typeof t), i = (e) => e && !!e[t], o = (n, s, c) => {
+	if (i(n)) {
+		const { matched: r, selections: i } = n[t]().match(s);
+		return r && i && Object.keys(i).forEach((t) => c(t, i[t])), r;
+	}
+	if (r(n)) {
+		if (!r(s)) return !1;
+		if (Array.isArray(n)) {
+			if (!Array.isArray(s)) return !1;
+			let t = [], r = [], u = [];
+			for (const o of n.keys()) {
+				const s$1 = n[o];
+				i(s$1) && s$1[e] ? u.push(s$1) : u.length ? r.push(s$1) : t.push(s$1);
+			}
+			if (u.length) {
+				if (u.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+				if (s.length < t.length + r.length) return !1;
+				const e = s.slice(0, t.length), n$1 = 0 === r.length ? [] : s.slice(-r.length), i = s.slice(t.length, 0 === r.length ? Infinity : -r.length);
+				return t.every((t$1, n$2) => o(t$1, e[n$2], c)) && r.every((t$1, e$1) => o(t$1, n$1[e$1], c)) && (0 === u.length || o(u[0], i, c));
+			}
+			return n.length === s.length && n.every((t$1, e) => o(t$1, s[e], c));
+		}
+		return Reflect.ownKeys(n).every((e) => {
+			const r = n[e];
+			return (e in s || i(u = r) && "optional" === u[t]().matcherType) && o(r, s[e], c);
+			var u;
+		});
+	}
+	return Object.is(s, n);
+}, s = (e) => {
+	var n, o, u;
+	return r(e) ? i(e) ? null != (n = null == (o = (u = e[t]()).getSelectionKeys) ? void 0 : o.call(u)) ? n : [] : Array.isArray(e) ? c(e, s) : c(Object.values(e), s) : [];
+}, c = (t, e) => t.reduce((t$1, n) => t$1.concat(e(n)), []);
+function u(...t) {
+	if (1 === t.length) {
+		const [e] = t;
+		return (t$1) => o(e, t$1, () => {});
+	}
+	if (2 === t.length) {
+		const [e, n] = t;
+		return o(e, n, () => {});
+	}
+	throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`);
+}
+function a(t) {
+	return Object.assign(t, {
+		optional: () => h(t),
+		and: (e) => d(t, e),
+		or: (e) => y(t, e),
+		select: (e) => void 0 === e ? v(t) : v(e, t)
+	});
+}
+function l(t) {
+	return Object.assign(((t$1) => Object.assign(t$1, { [Symbol.iterator]() {
+		let n = 0;
+		const r = [{
+			value: Object.assign(t$1, { [e]: !0 }),
+			done: !1
+		}, {
+			done: !0,
+			value: void 0
+		}];
+		return { next: () => {
+			var t$2;
+			return null != (t$2 = r[n++]) ? t$2 : r.at(-1);
+		} };
+	} }))(t), {
+		optional: () => l(h(t)),
+		select: (e) => l(void 0 === e ? v(t) : v(e, t))
+	});
+}
+function h(e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t$1, e$1) => {
+				n[t$1] = e$1;
+			};
+			return void 0 === t ? (s(e).forEach((t$1) => r(t$1, void 0)), {
+				matched: !0,
+				selections: n
+			}) : {
+				matched: o(e, t, r),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => s(e),
+		matcherType: "optional"
+	}) });
+}
+const f = (t, e) => {
+	for (const n of t) if (!e(n)) return !1;
+	return !0;
+}, g = (t, e) => {
+	for (const [n, r] of t.entries()) if (!e(r, n)) return !1;
+	return !0;
+}, m = (t, e) => {
+	const n = Reflect.ownKeys(t);
+	for (const r of n) if (!e(r, t[r])) return !1;
+	return !0;
+};
+function d(...e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t$1, e$1) => {
+				n[t$1] = e$1;
+			};
+			return {
+				matched: e.every((e$1) => o(e$1, t, r)),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => c(e, s),
+		matcherType: "and"
+	}) });
+}
+function y(...e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t$1, e$1) => {
+				n[t$1] = e$1;
+			};
+			return c(e, s).forEach((t$1) => r(t$1, void 0)), {
+				matched: e.some((e$1) => o(e$1, t, r)),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => c(e, s),
+		matcherType: "or"
+	}) });
+}
+function p(e) {
+	return { [t]: () => ({ match: (t) => ({ matched: Boolean(e(t)) }) }) };
+}
+function v(...e) {
+	const r = "string" == typeof e[0] ? e[0] : void 0, i = 2 === e.length ? e[1] : "string" == typeof e[0] ? void 0 : e[0];
+	return a({ [t]: () => ({
+		match: (t) => {
+			let e$1 = { [null != r ? r : n]: t };
+			return {
+				matched: void 0 === i || o(i, t, (t$1, n) => {
+					e$1[t$1] = n;
+				}),
+				selections: e$1
+			};
+		},
+		getSelectionKeys: () => [null != r ? r : n].concat(void 0 === i ? [] : s(i))
+	}) });
+}
+function b(t) {
+	return !0;
+}
+function w(t) {
+	return "number" == typeof t;
+}
+function S(t) {
+	return "string" == typeof t;
+}
+function j(t) {
+	return "bigint" == typeof t;
+}
+const K = a(p(b)), O = a(p(b)), E = K, x = (t) => Object.assign(a(t), {
+	startsWith: (e) => {
+		return x(d(t, (n = e, p((t$1) => S(t$1) && t$1.startsWith(n)))));
+		var n;
+	},
+	endsWith: (e) => {
+		return x(d(t, (n = e, p((t$1) => S(t$1) && t$1.endsWith(n)))));
+		var n;
+	},
+	minLength: (e) => x(d(t, ((t$1) => p((e$1) => S(e$1) && e$1.length >= t$1))(e))),
+	length: (e) => x(d(t, ((t$1) => p((e$1) => S(e$1) && e$1.length === t$1))(e))),
+	maxLength: (e) => x(d(t, ((t$1) => p((e$1) => S(e$1) && e$1.length <= t$1))(e))),
+	includes: (e) => {
+		return x(d(t, (n = e, p((t$1) => S(t$1) && t$1.includes(n)))));
+		var n;
+	},
+	regex: (e) => {
+		return x(d(t, (n = e, p((t$1) => S(t$1) && Boolean(t$1.match(n))))));
+		var n;
+	}
+}), A = x(p(S)), N = (t) => Object.assign(a(t), {
+	between: (e, n) => N(d(t, ((t$1, e$1) => p((n$1) => w(n$1) && t$1 <= n$1 && e$1 >= n$1))(e, n))),
+	lt: (e) => N(d(t, ((t$1) => p((e$1) => w(e$1) && e$1 < t$1))(e))),
+	gt: (e) => N(d(t, ((t$1) => p((e$1) => w(e$1) && e$1 > t$1))(e))),
+	lte: (e) => N(d(t, ((t$1) => p((e$1) => w(e$1) && e$1 <= t$1))(e))),
+	gte: (e) => N(d(t, ((t$1) => p((e$1) => w(e$1) && e$1 >= t$1))(e))),
+	int: () => N(d(t, p((t$1) => w(t$1) && Number.isInteger(t$1)))),
+	finite: () => N(d(t, p((t$1) => w(t$1) && Number.isFinite(t$1)))),
+	positive: () => N(d(t, p((t$1) => w(t$1) && t$1 > 0))),
+	negative: () => N(d(t, p((t$1) => w(t$1) && t$1 < 0)))
+}), P = N(p(w)), k = (t) => Object.assign(a(t), {
+	between: (e, n) => k(d(t, ((t$1, e$1) => p((n$1) => j(n$1) && t$1 <= n$1 && e$1 >= n$1))(e, n))),
+	lt: (e) => k(d(t, ((t$1) => p((e$1) => j(e$1) && e$1 < t$1))(e))),
+	gt: (e) => k(d(t, ((t$1) => p((e$1) => j(e$1) && e$1 > t$1))(e))),
+	lte: (e) => k(d(t, ((t$1) => p((e$1) => j(e$1) && e$1 <= t$1))(e))),
+	gte: (e) => k(d(t, ((t$1) => p((e$1) => j(e$1) && e$1 >= t$1))(e))),
+	positive: () => k(d(t, p((t$1) => j(t$1) && t$1 > 0))),
+	negative: () => k(d(t, p((t$1) => j(t$1) && t$1 < 0)))
+});
+var z = {
+	__proto__: null,
+	matcher: t,
+	optional: h,
+	array: function(...e) {
+		return l({ [t]: () => ({
+			match: (t) => {
+				if (!Array.isArray(t)) return { matched: !1 };
+				if (0 === e.length) return { matched: !0 };
+				const n = e[0];
+				let r = {};
+				if (0 === t.length) return s(n).forEach((t$1) => {
+					r[t$1] = [];
+				}), {
+					matched: !0,
+					selections: r
+				};
+				const i = (t$1, e$1) => {
+					r[t$1] = (r[t$1] || []).concat([e$1]);
+				};
+				return {
+					matched: t.every((t$1) => o(n, t$1, i)),
+					selections: r
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : s(e[0])
+		}) });
+	},
+	set: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (!(t instanceof Set)) return { matched: !1 };
+				let n = {};
+				if (0 === t.size) return {
+					matched: !0,
+					selections: n
+				};
+				if (0 === e.length) return { matched: !0 };
+				const r = (t$1, e$1) => {
+					n[t$1] = (n[t$1] || []).concat([e$1]);
+				}, i = e[0];
+				return {
+					matched: f(t, (t$1) => o(i, t$1, r)),
+					selections: n
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : s(e[0])
+		}) });
+	},
+	map: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (!(t instanceof Map)) return { matched: !1 };
+				let n = {};
+				if (0 === t.size) return {
+					matched: !0,
+					selections: n
+				};
+				const r = (t$1, e$1) => {
+					n[t$1] = (n[t$1] || []).concat([e$1]);
+				};
+				if (0 === e.length) return { matched: !0 };
+				var i;
+				if (1 === e.length) throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i = e[0]) ? void 0 : i.toString()}`);
+				const [s, c] = e;
+				return {
+					matched: g(t, (t$1, e$1) => {
+						const n$1 = o(s, e$1, r), i$1 = o(c, t$1, r);
+						return n$1 && i$1;
+					}),
+					selections: n
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : [...s(e[0]), ...s(e[1])]
+		}) });
+	},
+	record: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (null === t || "object" != typeof t || Array.isArray(t)) return { matched: !1 };
+				var n;
+				if (0 === e.length) throw new Error(`\`P.record\` wasn't given enough arguments. Expected (value) or (key, value), received ${null == (n = e[0]) ? void 0 : n.toString()}`);
+				let r = {};
+				const i = (t$1, e$1) => {
+					r[t$1] = (r[t$1] || []).concat([e$1]);
+				}, [s, c] = 1 === e.length ? [A, e[0]] : e;
+				return {
+					matched: m(t, (t$1, e$1) => {
+						const n$1 = "string" != typeof t$1 || Number.isNaN(Number(t$1)) ? null : Number(t$1), r$1 = null !== n$1 && o(s, n$1, i), u = o(s, t$1, i), a = o(c, e$1, i);
+						return (u || r$1) && a;
+					}),
+					selections: r
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : [...s(e[0]), ...s(e[1])]
+		}) });
+	},
+	intersection: d,
+	union: y,
+	not: function(e) {
+		return a({ [t]: () => ({
+			match: (t) => ({ matched: !o(e, t, () => {}) }),
+			getSelectionKeys: () => [],
+			matcherType: "not"
+		}) });
+	},
+	when: p,
+	select: v,
+	any: K,
+	unknown: O,
+	_: E,
+	string: A,
+	number: P,
+	bigint: k(p(j)),
+	boolean: a(p(function(t) {
+		return "boolean" == typeof t;
+	})),
+	symbol: a(p(function(t) {
+		return "symbol" == typeof t;
+	})),
+	nullish: a(p(function(t) {
+		return null == t;
+	})),
+	nonNullable: a(p(function(t) {
+		return null != t;
+	})),
+	instanceOf: function(t) {
+		return a(p(function(t$1) {
+			return (e) => e instanceof t$1;
+		}(t)));
+	},
+	shape: function(t) {
+		return a(p(u(t)));
+	}
+};
+var I = class extends Error {
+	constructor(t) {
+		let e;
+		try {
+			e = JSON.stringify(t);
+		} catch (n) {
+			e = t;
+		}
+		super(`Pattern matching error: no pattern matches value ${e}`), this.input = void 0, this.input = t;
+	}
+};
+const L = {
+	matched: !1,
+	value: void 0
+};
+function M(t) {
+	return new R(t, L);
+}
+var R = class R {
+	constructor(t, e) {
+		this.input = void 0, this.state = void 0, this.input = t, this.state = e;
+	}
+	with(...t) {
+		if (this.state.matched) return this;
+		const e = t[t.length - 1], r = [t[0]];
+		let i;
+		3 === t.length && "function" == typeof t[1] ? i = t[1] : t.length > 2 && r.push(...t.slice(1, t.length - 1));
+		let s = !1, c = {};
+		const u = (t$1, e$1) => {
+			s = !0, c[t$1] = e$1;
+		}, a = !r.some((t$1) => o(t$1, this.input, u)) || i && !Boolean(i(this.input)) ? L : {
+			matched: !0,
+			value: e(s ? n in c ? c[n] : c : this.input, this.input)
+		};
+		return new R(this.input, a);
+	}
+	when(t, e) {
+		if (this.state.matched) return this;
+		const n = Boolean(t(this.input));
+		return new R(this.input, n ? {
+			matched: !0,
+			value: e(this.input, this.input)
+		} : L);
+	}
+	otherwise(t) {
+		return this.state.matched ? this.state.value : t(this.input);
+	}
+	exhaustive(t = F) {
+		return this.state.matched ? this.state.value : t(this.input);
+	}
+	run() {
+		return this.exhaustive();
+	}
+	returnType() {
+		return this;
+	}
+	narrow() {
+		return this;
+	}
+};
+function F(t) {
+	throw new I(t);
+}
+
+//#endregion
+//#region src/utils/type-is.ts
+function isFlagSet(allFlags, flag) {
+	return (allFlags & flag) !== 0;
+}
+function isFlagSetOnObject(obj, flag) {
+	return isFlagSet(obj.flags, flag);
+}
+const isTypeFlagSet = isFlagSetOnObject;
+function isBooleanLiteralType(type) {
+	return isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral);
+}
+/** @internal */
+const isFalseLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "false";
+/** @internal */
+const isTrueLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "true";
+/** @internal */
+const isAnyType = (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any);
+/** @internal */
+const isBigIntType = (type) => isTypeFlagSet(type, ts.TypeFlags.BigIntLike);
+/** @internal */
+const isBooleanType = (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLike);
+/** @internal */
+const isEnumType = (type) => isTypeFlagSet(type, ts.TypeFlags.EnumLike);
+/** @internal */
+const isFalsyBigIntType = (type) => type.isLiteral() && u({ value: { base10Value: "0" } }, type);
+/** @internal */
+const isFalsyNumberType = (type) => type.isNumberLiteral() && type.value === 0;
+/** @internal */
+const isFalsyStringType = (type) => type.isStringLiteral() && type.value === "";
+/** @internal */
+const isNeverType = (type) => isTypeFlagSet(type, ts.TypeFlags.Never);
+/** @internal */
+const isNullishType = (type) => isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike);
+/** @internal */
+const isNumberType = (type) => isTypeFlagSet(type, ts.TypeFlags.NumberLike);
+/** @internal */
+const isObjectType = (type) => !isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never);
+/** @internal */
+const isStringType = (type) => isTypeFlagSet(type, ts.TypeFlags.StringLike);
+/** @internal */
+const isTruthyBigIntType = (type) => type.isLiteral() && u({ value: { base10Value: z.not("0") } }, type);
+/** @internal */
+const isTruthyNumberType = (type) => type.isNumberLiteral() && type.value !== 0;
+/** @internal */
+const isTruthyStringType = (type) => type.isStringLiteral() && type.value !== "";
+/** @internal */
+const isUnknownType = (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown);
+
+//#endregion
+//#region src/utils/type-variant.ts
+/**
+* Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements
+* Get the variants of an array of types.
+* @param types The types to get the variants of
+* @returns The variants of the types
+* @internal
+*/
+function getTypeVariants(types) {
+	const variants = /* @__PURE__ */ new Set();
+	if (types.some(isUnknownType)) {
+		variants.add("unknown");
+		return variants;
+	}
+	if (types.some(isNullishType)) variants.add("nullish");
+	const booleans = types.filter(isBooleanType);
+	const boolean0 = booleans[0];
+	if (booleans.length === 1 && boolean0 != null) {
+		if (isFalseLiteralType(boolean0)) variants.add("falsy boolean");
+		else if (isTrueLiteralType(boolean0)) variants.add("truthy boolean");
+	} else if (booleans.length === 2) variants.add("boolean");
+	const strings = types.filter(isStringType);
+	if (strings.length > 0) {
+		const evaluated = M(strings).when((types$1) => types$1.every(isTruthyStringType), () => "truthy string").when((types$1) => types$1.every(isFalsyStringType), () => "falsy string").otherwise(() => "string");
+		variants.add(evaluated);
+	}
+	const bigints = types.filter(isBigIntType);
+	if (bigints.length > 0) {
+		const evaluated = M(bigints).when((types$1) => types$1.every(isTruthyBigIntType), () => "truthy bigint").when((types$1) => types$1.every(isFalsyBigIntType), () => "falsy bigint").otherwise(() => "bigint");
+		variants.add(evaluated);
+	}
+	const numbers = types.filter(isNumberType);
+	if (numbers.length > 0) {
+		const evaluated = M(numbers).when((types$1) => types$1.every(isTruthyNumberType), () => "truthy number").when((types$1) => types$1.every(isFalsyNumberType), () => "falsy number").otherwise(() => "number");
+		variants.add(evaluated);
+	}
+	if (types.some(isEnumType)) variants.add("enum");
+	if (types.some(isObjectType)) variants.add("object");
+	if (types.some(isAnyType)) variants.add("any");
+	if (types.some(isNeverType)) variants.add("never");
+	return variants;
+}
+
+//#endregion
 //#region src/rules/no-leaked-conditional-rendering.ts
 /** @internal */
-const messages = { noLeakedConditionalRendering: (p) => `Potential leaked value ${p.value} that might cause unintentionally rendered values or rendering crashes.` };
+const messages = { noLeakedConditionalRendering: (p$1) => `Potential leaked value ${p$1.value} that might cause unintentionally rendered values or rendering crashes.` };
 /**
 * Prevents problematic leaked values from being rendered.
 *
@@ -68,6 +563,7 @@ const noLeakedConditionalRendering = defineRule(() => {
 			const state = { isWithinJsxExpression: false };
 			const allowedVariants = [
 				"any",
+				"enum",
 				"boolean",
 				"nullish",
 				"object",
@@ -81,7 +577,7 @@ const noLeakedConditionalRendering = defineRule(() => {
 			function getReportDescriptor(node) {
 				if (isLogicalNegationExpression(node.left)) return unit;
 				const leftType = ctx.utils.getConstrainedTypeAtLocation(node.left);
-				const leftTypeVariants = getVariantsOfTypes(ctx.utils.unionConstituents(leftType));
+				const leftTypeVariants = getTypeVariants(ctx.utils.unionConstituents(leftType));
 				if (!Array.from(leftTypeVariants.values()).every((type) => allowedVariants.some((allowed) => allowed === type))) return {
 					node: node.left,
 					message: messages.noLeakedConditionalRendering({ value: node.left.getText() })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-react",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "A unified plugin that combines all individual plugins from the react-analyzer monorepo into one.",
   "keywords": [
     "react",
@@ -29,16 +29,16 @@
   "dependencies": {
     "@let/eff": "npm:@jsr/let__eff@^0.1.2",
     "compare-versions": "^6.1.1",
-    "@react-analyzer/ast": "0.0.6",
-    "@react-analyzer/core": "0.0.6",
-    "@react-analyzer/shared": "0.0.6"
+    "@react-analyzer/ast": "0.0.8",
+    "@react-analyzer/shared": "0.0.8",
+    "@react-analyzer/core": "0.0.8"
   },
   "devDependencies": {
-    "tsdown": "^0.18.3",
+    "tsdown": "^0.20.0-beta.4",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "tsl": "^1.0.27",
+    "tsl": "^1.0.28",
     "typescript": "^4.9.5 || ^5.4.5"
   },
   "engines": {