@deslop/coding-standards 0.1.1249 → 0.1.1252

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)
@@ -7691,7 +7845,7 @@ const noFloatingDerivedType = defineRule({
 });
 // src/rules/no-gradient.ts
 const GRADIENT = /(?:^|[\s:])bg-(?:linear|radial|conic|gradient)(?:-|$|\s)|gradient\(/u;
-function report$5(context, node) {
+function report$6(context, node) {
 	context.report({
 		message: "Use a flat theme token such as bg-card or bg-muted; gradients are never part of the design.",
 		node
@@ -7700,10 +7854,10 @@ function report$5(context, node) {
 const noGradient = defineRule({
 	create: (context) => ({
 		Literal: (node) => {
-			if (isString(node.value) && GRADIENT.test(node.value)) report$5(context, node);
+			if (isString(node.value) && GRADIENT.test(node.value)) report$6(context, node);
 		},
 		TemplateElement: (node) => {
-			if (GRADIENT.test(node.value.raw)) report$5(context, node);
+			if (GRADIENT.test(node.value.raw)) report$6(context, node);
 		}
 	}),
 	meta: { type: "problem" }
@@ -7791,7 +7945,7 @@ function replaceableGuard(node) {
 		"typeof === undefined": "isUndefined"
 	}, key)));
 }
-function report$4(input) {
+function report$5(input) {
 	map$1(replaceableGuard(input.node), (guard) => input.context.report({
 		message: `Use Predicate.${guard} instead of this hand-written type guard.`,
 		node: input.node
@@ -7800,19 +7954,19 @@ function report$4(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
@@ -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",
@@ -8400,7 +8687,7 @@ function replacement(input) {
 	if (input.read.parent?.type === "Property" && input.read.parent.shorthand) return `${input.name}: ${input.text}`;
 	return input.text;
 }
-function report$3(input) {
+function report$4(input) {
 	const reads = pipe(input.variable.references, filter((reference) => reference.isRead()), map((reference) => reference.identifier));
 	const text = input.context.sourceCode.getText(input.init);
 	const aliasRequired = needsAlias({
@@ -8479,7 +8766,7 @@ const noPropertyAlias = defineRule({
 					scope: context.sourceCode.getScope(candidate.node)
 				}), match$2({
 					onNone: constVoid,
-					onSome: (variable) => report$3({
+					onSome: (variable) => report$4({
 						...candidate,
 						context,
 						variable,
@@ -8675,7 +8962,7 @@ const shipped = [
 		schema: "Natural"
 	}
 ];
-function schemaMember$1(input) {
+function schemaMember$2(input) {
 	if (input.node.type !== "MemberExpression" || !importedMember({
 		context: input.context,
 		importedName: "Schema",
@@ -8685,11 +8972,11 @@ function schemaMember$1(input) {
 }
 function shippedSchema(input) {
 	if (input.filter.type !== "CallExpression") return none();
-	const base = schemaMember$1({
+	const base = schemaMember$2({
 		context: input.context,
 		node: input.base
 	});
-	const check = schemaMember$1({
+	const check = schemaMember$2({
 		context: input.context,
 		node: input.filter.callee
 	});
@@ -8712,7 +8999,7 @@ function reinventedSchema(input) {
 	if (input.node.callee.type !== "MemberExpression" || !contains$1(memberName(input.node.callee), "check")) return none();
 	const callee = input.node.callee;
 	const [filter] = input.node.arguments;
-	if (isSome(schemaMember$1({
+	if (isSome(schemaMember$2({
 		context: input.context,
 		node: callee
 	}))) {
@@ -9275,7 +9562,7 @@ function executes(context, node) {
 function receiver(read) {
 	return read.parent?.type === "MemberExpression" && read.parent.object === read && read.parent.parent.type === "CallExpression" && read.parent.parent.callee === read.parent;
 }
-function report$2(input) {
+function report$3(input) {
 	const declaration = input.node.parent;
 	const init = input.node.init;
 	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null) return;
@@ -9332,7 +9619,7 @@ const noSingleUseValue = defineRule({
 			NewExpression: effect,
 			"Program:exit": () => {
 				const nodes = toArray(effects);
-				for (const node of toArray(candidates)) report$2({
+				for (const node of toArray(candidates)) report$3({
 					context,
 					effects: nodes,
 					node
@@ -9639,7 +9926,7 @@ const noTestTimeout = defineRule({
 	meta: { type: "problem" }
 });
 // src/rules/no-type-from-value.ts
-function schemaMember(name) {
+function schemaMember$1(name) {
 	return name.type === "TSQualifiedName" && contains([
 		"Encoded",
 		"Type",
@@ -9652,7 +9939,7 @@ function schemaMember(name) {
 function valueQuery(node) {
 	if (node.type === "TSParenthesizedType") return valueQuery(node.typeAnnotation);
 	if (node.type === "TSIndexedAccessType") return valueQuery(node.objectType);
-	return node.type === "TSTypeQuery" && (node.exprName.type === "Identifier" || node.exprName.type === "TSQualifiedName" && !schemaMember(node.exprName));
+	return node.type === "TSTypeQuery" && (node.exprName.type === "Identifier" || node.exprName.type === "TSQualifiedName" && !schemaMember$1(node.exprName));
 }
 function nestedObject(node) {
 	return node.parent?.type === "TSIndexedAccessType" && node.parent.objectType === node;
@@ -10001,7 +10288,7 @@ function fix(input) {
 		return some$1([input.fixer.replaceTextRange([open.range[0], close.range[1]], "(cause)"), insertion]);
 	}), () => []);
 }
-function report$1(context, node) {
+function report$2(context, node) {
 	context.report({
 		fix: (fixer) => fix({
 			context,
@@ -10014,7 +10301,7 @@ function report$1(context, node) {
 }
 function reportOption(context, key, bare, options) {
 	if (options?.type !== "ObjectExpression") return;
-	for (const property of options.properties) if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === key && dropsCause(context, property.value, bare)) report$1(context, property.value);
+	for (const property of options.properties) if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === key && dropsCause(context, property.value, bare)) report$2(context, property.value);
 }
 const preserveErrorCause = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -10024,7 +10311,7 @@ const preserveErrorCause = defineRule({
 		});
 		if (contains$1(name, "mapError")) {
 			const bare = detailedFailure(context, node);
-			forEach(filter(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$1(context, callback));
+			forEach(filter(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$2(context, callback));
 			return;
 		}
 		if (contains$1(name, "mapBoth")) {
@@ -10275,6 +10562,125 @@ const schemaTypePair = defineRule({
 		type: "problem"
 	}
 });
+// src/rules/service-schema-file.ts
+const SERVICE_PATH = /[/\\]src[/\\]services[/\\][^/\\]+[/\\]/u;
+const SCHEMA_FILE = /[/\\]schema\.ts$/u;
+const SCHEMA_CLASSES = [
+	"Class",
+	"TaggedClass",
+	"TaggedError",
+	"TaggedRequest"
+];
+const DERIVED = matches(/^(?:is|to)[A-Z]/u);
+const FILTER = matches(/^makeFilter(?:Group)?$/u);
+function schemaMember(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type !== "Super") return schemaMember({
+		context: input.context,
+		node: input.node.callee
+	});
+	if (input.node.type === "ChainExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "TSInstantiationExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "TSSatisfiesExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "MemberExpression") {
+		if (input.node.object.type === "Identifier") return some$1(input.node);
+		if (input.node.object.type !== "Super") return schemaMember({
+			context: input.context,
+			node: input.node.object
+		});
+	}
+	return none();
+}
+function constructorMember(input) {
+	return importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	}) && pipe(memberName(input.node), exists((name) => !isSchemaOperationName(name) && !DERIVED(name) && !FILTER(name)));
+}
+function definesSchema(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type === "Identifier" && isImportBinding({
+		context: input.context,
+		importedName: "pipe",
+		node: input.node.callee,
+		source: "effect"
+	})) {
+		const [first] = input.node.arguments;
+		return first !== void 0 && first.type !== "SpreadElement" && definesSchema({
+			...input,
+			node: first
+		});
+	}
+	return pipe(schemaMember(input), exists((member) => constructorMember({
+		context: input.context,
+		node: member
+	})));
+}
+function schemaClass(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type !== "Super") return schemaClass({
+		context: input.context,
+		node: input.node.callee
+	});
+	if (input.node.type === "TSInstantiationExpression") return schemaClass({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "MemberExpression" && input.node.object.type === "Identifier" && importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	})) return pipe(memberName(input.node), exists((name) => contains(SCHEMA_CLASSES, name)));
+	return false;
+}
+function extendsSchema(input) {
+	return input.node.superClass !== null && schemaClass({
+		context: input.context,
+		node: input.node.superClass
+	});
+}
+function report$1(context, node) {
+	context.report({
+		message: "Move this schema into the service's schema.ts and import it.",
+		node
+	});
+}
+function exported(statement) {
+	if (statement.type === "ExportDefaultDeclaration") return statement.declaration;
+	return statementDeclaration(statement);
+}
+function definitions(context, declaration) {
+	if (declaration?.type === "VariableDeclaration" && declaration.kind === "const") return flatMap(declaration.declarations, (variable) => {
+		if (variable.init === null) return empty$2();
+		if (variable.init.type === "ClassExpression") return filter([variable.init], (node) => extendsSchema({
+			context,
+			node
+		}));
+		return filter([variable.init], (node) => definesSchema({
+			context,
+			node
+		}));
+	});
+	if (declaration?.type === "ClassDeclaration" || declaration?.type === "ClassExpression") return filter([declaration], (node) => extendsSchema({
+		context,
+		node
+	}));
+	return empty$2();
+}
+const serviceSchemaFile = defineRule({
+	create: (context) => ({ Program: (program) => {
+		if (!SERVICE_PATH.test(context.filename) || SCHEMA_FILE.test(context.filename) || isTestFile(context)) return;
+		for (const node of flatMap(program.body, (statement) => definitions(context, exported(statement)))) report$1(context, node);
+	} }),
+	meta: { type: "problem" }
+});
 // src/rules/swiftui-theme-values.ts
 const PAINTS = [
 	"background",
@@ -10409,6 +10815,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,
@@ -10435,6 +10842,7 @@ const RULES = {
 	"preserve-error-cause": preserveErrorCause,
 	"require-unicode-regexp": requireUnicodeRegexp,
 	"schema-type-pair": schemaTypePair,
+	"service-schema-file": serviceSchemaFile,
 	"swiftui-theme-values": swiftuiThemeValues
 };
 const lint = {
@@ -11315,7 +11723,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.1249",
+  "version": "0.1.1252",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",