@deslop/coding-standards 0.1.1248 → 0.1.1250

package/dist/lint.js

@@ -2307,6 +2307,19 @@ const succeed = (success) => new SuccessImpl(success);
 const fromOption$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone$1(self) ? fail(onNone()) : succeed(self.value));
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/Order.js
 /**
+* Defines comparison functions for ordered values.
+*
+* An `Order<A>` compares two `A` values and returns whether the first is less
+* than, equal to, or greater than the second. Orders are used for sorting,
+* choosing minimum or maximum values, checking ranges, and building ordered data
+* structures. This module includes built-in orders, constructors for custom
+* orders, tools for reversing and combining comparisons, tuple and struct
+* helpers, comparison predicates, clamping, and reducer support.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
 * Creates a new `Order` instance from a comparison function.
 *
 * **When to use**
@@ -2374,6 +2387,76 @@ function make$4(compare) {
 * @since 4.0.0
 */
 const String$2 = /*#__PURE__*/ make$4((self, that) => self < that ? -1 : 1);
+/**
+* Order instance for numbers that compares them numerically.
+*
+* **When to use**
+*
+* Use when you need numeric ordering for numbers.
+*
+* **Details**
+*
+* `0` is considered equal to `-0`. All `NaN` values are considered equal to
+* each other, and any `NaN` is considered less than any non-`NaN` number. All
+* other values use standard numeric comparison.
+*
+* **Example** (Ordering numbers)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* Order.Number(1, 1) // => 0
+* Order.Number(1, 2) // => -1
+* Order.Number(2, 1) // => 1
+*
+* Order.Number(0, -0) // => 0
+* Order.Number(NaN, 1) // => -1
+* ```
+*
+* @see {@link mapInput} to compare objects by a number property
+* @see {@link BigInt} for bigint comparisons
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const Number$2 = /*#__PURE__*/ make$4((self, that) => {
+	if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
+	if (globalThis.Number.isNaN(self)) return -1;
+	if (globalThis.Number.isNaN(that)) return 1;
+	return self < that ? -1 : 1;
+});
+/**
+* Returns the maximum of two values according to the given order. If they are equal, returns the first argument.
+*
+* **When to use**
+*
+* Use when you need to select the larger of two values according to an
+* `Order`.
+*
+* **Details**
+*
+* Returns the value that compares as greater than or equal to the other value.
+* If values are equal, the first argument is returned.
+*
+* **Example** (Selecting the maximum value)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const maxNumber = Order.max(Order.Number)
+*
+* maxNumber(1, 2) // => 2
+* maxNumber(2, 1) // => 2
+* maxNumber(1, 1) // => 1
+* ```
+*
+* @see {@link min} for the minimum of two values
+* @see {@link clamp} to clamp a value between min and max
+* @stability stable
+* @category comparisons
+* @since 2.0.0
+*/
+const max$1 = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/Option.js
 /**
 * Creates an `Option` representing the absence of a value.
@@ -4565,6 +4648,33 @@ const filter = /*#__PURE__*/ dual(2, (self, predicate) => {
 	return out;
 });
 /**
+* Folds an iterable from left to right into a single value.
+*
+* **When to use**
+*
+* Use to combine all elements into one accumulated value from left to right.
+*
+* **Details**
+*
+* The function receives `(accumulator, element, index)`.
+*
+* **Example** (Summing an array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) // => 6
+* ```
+*
+* @see {@link reduceRight} — fold from right to left
+* @see {@link scan} — fold keeping intermediate values
+*
+* @stability stable
+* @category folding
+* @since 2.0.0
+*/
+const reduce = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
+/**
 * Checks whether all elements satisfy the predicate. Supports refinements for
 * type narrowing.
 *
@@ -4832,6 +4942,28 @@ const TaggedError = TaggedError$1;
 */
 const Number$1 = globalThis.Number;
 /**
+* Returns the maximum between two `number`s.
+*
+* **When to use**
+*
+* Use to select the larger of two numbers.
+*
+* **Example** (Finding the maximum)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.max(2, 3) // => 3
+* ```
+*
+* @see {@link min} for selecting the smaller value
+*
+* @stability stable
+* @category math
+* @since 2.0.0
+*/
+const max = /*#__PURE__*/ max$1(Number$2);
+/**
 * Parses a `number` from a `string` safely using the `Number()` function.
 * The following special string values are supported: "NaN", "Infinity", "-Infinity".
 *
@@ -4904,6 +5036,28 @@ const Order = String$2;
 */
 const toUpperCase = (self) => self.toUpperCase();
 /**
+* Replaces matches in a string using `String.prototype.replace`.
+*
+* **Details**
+*
+* String search values and non-global regular expressions replace the first
+* match; global regular expressions replace every match.
+*
+* **Example** (Replacing a substring)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("abc", String.replace("b", "d")) // => "adc"
+* pipe("hello world", String.replace("world", "Effect")) // => "hello Effect"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const replace = (searchValue, replaceValue) => (self) => self.replace(searchValue, replaceValue);
+/**
 * Removes whitespace from both ends of a string.
 *
 * **Example** (Trimming whitespace)
@@ -6909,8 +7063,8 @@ function amount(token, pattern) {
 function violation(token) {
 	const name = pipe(token, split(":"), last, getOrElse(() => token), replaceAll(/^!|!$/gu, ""));
 	if (exists(amount(name, /^duration-(\d+)$/u), (value) => value >= 300)) return some$1("Keep a tween under 300 ms, such as duration-200.");
-	if (matches(/^zoom-(?:in|out)$/u)(name) || exists(amount(name, /^zoom-(?:in|out)-(\d+)$/u), (value) => value < 90)) return some$1("Enter from 0.9 scale or more: zoom-in-90 or zoom-in-95.");
-	if (pipe(token, split(":"), dropRight(1), contains("starting")) && exists(amount(name, /^scale-(\d+)$/u), (value) => value < 90)) return some$1("Enter from 0.9 scale or more: starting:scale-90 or starting:scale-95.");
+	if (matches(/^zoom-(?:in|out)$/u)(name) || exists(amount(name, /^zoom-(?:in|out)-(\d+)$/u), (value) => value < 90)) return some$1("Enter from 0.95 scale with opacity: zoom-in-95.");
+	if (pipe(token, split(":"), dropRight(1), contains("starting")) && exists(amount(name, /^scale-(\d+)$/u), (value) => value < 90)) return some$1("Enter from 0.95 scale with opacity: starting:scale-95.");
 	return none();
 }
 function check$2(context, node, text) {
@@ -7863,14 +8017,14 @@ const PRIMITIVES = {
 	textarea: "Textarea"
 };
 const CONTROL_STYLE = /(?:^|:)(?:hover|focus|focus-visible|active):|(?:^|:)(?:rounded|shadow|ring)(?:-|$)|(?:^|:)p[blrtxy]?-(?!0$)|(?:^|:)bg-(?!transparent$)|(?:^|:)border(?:-[blrtxy])?$|(?:^|:)border-(?!0$|[blrtxy]-0$)/u;
-function classStrings(node) {
+function classStrings$1(node) {
 	if (node.type === "Literal") return filter([node.value], isString);
 	if (node.type === "TemplateLiteral") return map(node.quasis, (quasi) => quasi.value.raw);
-	if (node.type === "JSXExpressionContainer") return classStrings(node.expression);
-	if (node.type === "CallExpression") return flatMap(node.arguments, classStrings);
-	if (node.type === "ConditionalExpression") return flatMap([node.consequent, node.alternate], classStrings);
-	if (node.type === "LogicalExpression") return classStrings(node.right);
-	if (node.type === "ArrayExpression") return flatMap(filter(node.elements, isNotNull), classStrings);
+	if (node.type === "JSXExpressionContainer") return classStrings$1(node.expression);
+	if (node.type === "CallExpression") return flatMap(node.arguments, classStrings$1);
+	if (node.type === "ConditionalExpression") return flatMap([node.consequent, node.alternate], classStrings$1);
+	if (node.type === "LogicalExpression") return classStrings$1(node.right);
+	if (node.type === "ArrayExpression") return flatMap(filter(node.elements, isNotNull), classStrings$1);
 	return empty$2();
 }
 const noNativeControl = defineRule({
@@ -7880,7 +8034,7 @@ const noNativeControl = defineRule({
 		map$1(get$3(PRIMITIVES, name), (primitive) => {
 			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map$1((attribute) => {
 				if (attribute.type !== "JSXAttribute" || attribute.value === null) return empty$2();
-				return classStrings(attribute.value);
+				return classStrings$1(attribute.value);
 			}), exists((values) => some(values, (value) => some(split(value, /\s+/u), matches(CONTROL_STYLE)))));
 			if (name !== "select" && !styled) return;
 			context.report({
@@ -8304,6 +8458,139 @@ const noPollingTest = defineRule({
 	},
 	meta: { type: "problem" }
 });
+// src/rules/no-primitive-restyle.ts
+const UI_MODULES = ["@deslop/components-web/ui/", "#components/ui/"];
+const PLACEMENT_PREFIXES = [
+	"m-",
+	"mx-",
+	"my-",
+	"mt-",
+	"mr-",
+	"mb-",
+	"ml-",
+	"ms-",
+	"me-",
+	"w-",
+	"h-",
+	"size-",
+	"min-w-",
+	"min-h-",
+	"max-w-",
+	"max-h-",
+	"basis-",
+	"order-",
+	"col-span-",
+	"col-start-",
+	"col-end-",
+	"row-span-",
+	"row-start-",
+	"row-end-",
+	"self-",
+	"justify-self-",
+	"place-self-",
+	"inset-",
+	"inset-x-",
+	"inset-y-",
+	"top-",
+	"right-",
+	"bottom-",
+	"left-",
+	"start-",
+	"end-",
+	"z-",
+	"translate-",
+	"pointer-events-"
+];
+const PLACEMENT_EXACT = [
+	"flex-1",
+	"flex-auto",
+	"flex-none",
+	"grow",
+	"grow-0",
+	"shrink",
+	"shrink-0",
+	"relative",
+	"absolute",
+	"fixed",
+	"sticky",
+	"hidden",
+	"block",
+	"flex",
+	"inline-flex",
+	"grid",
+	"sr-only"
+];
+const RESTYLE = "A shadcn component keeps its shipped look: className only places it (margin, size, position, flex or grid placement). Pick a variant or change the composition instead of restyling.";
+function uiImport(program) {
+	return flatMap(program.body, (statement) => {
+		if (statement.type !== "ImportDeclaration") return empty$2();
+		if (!some(UI_MODULES, (prefix) => startsWith(prefix)(statement.source.value))) return empty$2();
+		return map(statement.specifiers, (specifier) => specifier.local.name);
+	});
+}
+function classStrings(node) {
+	if (node.type === "Literal") return filter([node.value], isString);
+	if (node.type === "TemplateLiteral") return map(node.quasis, (quasi) => quasi.value.raw);
+	if (node.type === "JSXExpressionContainer") return classStrings(node.expression);
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "cn") return flatMap(node.arguments, (argument) => classStrings(argument));
+	return empty$2();
+}
+function utility(token) {
+	const scanned = reduce(split("")(token), {
+		depth: 0,
+		end: 0,
+		index: 0
+	}, (state, character) => {
+		const index = state.index + 1;
+		if (character === "[") return {
+			depth: state.depth + 1,
+			end: state.end,
+			index
+		};
+		if (character === "]") return {
+			depth: max(0, state.depth - 1),
+			end: state.end,
+			index
+		};
+		if (character === ":" && state.depth === 0) return {
+			depth: state.depth,
+			end: index,
+			index
+		};
+		return {
+			depth: state.depth,
+			end: state.end,
+			index
+		};
+	});
+	return pipe(token, slice(scanned.end), replaceAll(/^!|!$/gu, ""), replace(/^-/u, ""));
+}
+function places(token) {
+	const name = utility(token);
+	return contains(PLACEMENT_EXACT, name) || some(PLACEMENT_PREFIXES, (prefix) => startsWith(prefix)(name));
+}
+function restyled(attribute) {
+	if (attribute.value === null) return false;
+	return pipe(classStrings(attribute.value), flatMap((value) => split(value, /\s+/u)), filter(isNonEmpty), some((token) => !places(token)));
+}
+const noPrimitiveRestyle = defineRule({
+	create: (context) => {
+		const file = { primitives: empty$2() };
+		return {
+			JSXOpeningElement: (node) => {
+				if (node.name.type !== "JSXIdentifier" || !contains(file.primitives, node.name.name)) return;
+				pipe(findFirst(node.attributes, (attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), filter$1((attribute) => attribute.type === "JSXAttribute" && restyled(attribute)), map$1((attribute) => context.report({
+					message: RESTYLE,
+					node: attribute
+				})));
+			},
+			Program: (node) => {
+				file.primitives = uiImport(node);
+			}
+		};
+	},
+	meta: { type: "problem" }
+});
 // src/rules/no-property-alias.ts
 const FUNCTIONS = [
 	"ArrowFunctionExpression",
@@ -10409,6 +10696,7 @@ const RULES = {
 	"no-option-value-access": noOptionValueAccess,
 	"no-pipe-method": noPipeMethod,
 	"no-polling-test": noPollingTest,
+	"no-primitive-restyle": noPrimitiveRestyle,
 	"no-property-alias": noPropertyAlias,
 	"no-redundant-state-type": noRedundantStateType,
 	"no-redundant-use-ref-null-type": noRedundantUseRefNullType,
@@ -11315,7 +11603,10 @@ const lint = {
 		"typescript/no-confusing-void-expression": ["error", { ignoreVoidReturningFunctions: true }],
 		"typescript/no-deprecated": "error",
 		"typescript/no-duplicate-type-constituents": "error",
-		"typescript/no-floating-promises": "error",
+		"typescript/no-floating-promises": ["error", { allowForKnownSafeCalls: [{
+			from: "file",
+			name: "navigate"
+		}] }],
 		"typescript/no-for-in-array": "error",
 		"typescript/no-generated-empty-object-type": "error",
 		"typescript/no-misused-promises": ["error", { checksVoidReturn: { attributes: false } }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1248",
+  "version": "0.1.1250",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",