praxis-kit 0.1.0

package/dist/contract/index.js

@@ -0,0 +1,341 @@
+//#region ../../lib/foundation/src/iterate.ts
+function find(iterable, callback) {
+	for (const value of iterable) {
+		const result = callback(value);
+		if (result != null) return result;
+	}
+	return null;
+}
+function some(iterable, predicate) {
+	for (const value of iterable) if (predicate(value)) return true;
+	return false;
+}
+function every(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (!predicate(value, index++)) return false;
+	return true;
+}
+function* filter(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (predicate(value, index++)) yield value;
+}
+function* map(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) yield callback(value, index++);
+}
+function forEach(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) callback(value, index++);
+}
+function reduce(iterable, initial, callback) {
+	let accumulator = initial;
+	let index = 0;
+	for (const value of iterable) accumulator = callback(accumulator, value, index++);
+	return accumulator;
+}
+/**
+* Transforms an iterable into a Record.
+*
+* The callback returns a `[key, value]` tuple for each element. Returning
+* `null` aborts the collection and causes `collect()` to return `null`.
+*/
+function collect(iterable, callback) {
+	const result = {};
+	let index = 0;
+	for (const value of iterable) {
+		const entry = callback(value, index++);
+		if (entry === null) return null;
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+function findLast(value, callback) {
+	for (let index = value.length - 1; index >= 0; index--) {
+		const result = callback(value[index], index);
+		if (result != null) return result;
+	}
+	return null;
+}
+function* items(collection) {
+	for (let i = 0; i < collection.length; i++) {
+		const item = collection.item(i);
+		if (item !== null) yield item;
+	}
+}
+function nodeList(list) {
+	return { *[Symbol.iterator]() {
+		for (let i = 0; i < list.length; i++) {
+			const node = list.item(i);
+			if (node !== null) yield node;
+		}
+	} };
+}
+function mapEntries(m) {
+	return m.entries();
+}
+function set(s) {
+	return s.values();
+}
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+function* entries(object) {
+	for (const key in object) {
+		if (!hasOwn(object, key)) continue;
+		yield [key, object[key]];
+	}
+}
+function* keys(object) {
+	for (const [key] of entries(object)) yield key;
+}
+function* values(object) {
+	for (const [, value] of entries(object)) yield value;
+}
+function mapValues(object, callback) {
+	const result = {};
+	for (const [key, value] of entries(object)) result[key] = callback(value, key);
+	return result;
+}
+function forEachEntry(object, callback) {
+	for (const [key, value] of entries(object)) callback(key, value);
+}
+function forEachKey(object, callback) {
+	for (const key of keys(object)) callback(key);
+}
+function forEachValue(object, callback) {
+	for (const value of values(object)) callback(value);
+}
+function forEachSet(s, callback) {
+	for (const value of s) callback(value);
+}
+const iterate = Object.freeze({
+	entries,
+	filter,
+	find,
+	findLast,
+	forEach,
+	forEachEntry,
+	forEachKey,
+	forEachSet,
+	forEachValue,
+	items,
+	keys,
+	map,
+	mapEntries,
+	mapValues,
+	nodeList,
+	reduce,
+	collect,
+	set,
+	some,
+	every,
+	values
+});
+//#endregion
+//#region ../../lib/foundation/src/type-guards.ts
+function isDefined(value) {
+	return value !== void 0;
+}
+function isUndefined(value) {
+	return value === void 0;
+}
+function isNull(value) {
+	return value === null;
+}
+function isNullish(value) {
+	return isNull(value) || isUndefined(value);
+}
+//#endregion
+//#region ../../lib/contract/src/props/make-state-normalizer.ts
+/**
+* Builds one of the eight built-in state-prop normalizers. A truthy state injects the `aria-*` /
+* `data-*` pair; the false state is handled per `falseState`; an explicitly supplied `aria-*` /
+* `data-*` value is never overwritten (the normalizer only fills when the key is `undefined`).
+*/
+function makeStateNormalizer({ state, aria, data, falseState = "omit" }) {
+	return (props) => {
+		const value = props[state];
+		if (falseState === "synthesize" ? isNullish(value) : !value) return {};
+		const out = {};
+		if (isUndefined(props[aria])) out[aria] = value ? "true" : "false";
+		if (value && isUndefined(props[data])) out[data] = "";
+		return out;
+	};
+}
+//#endregion
+//#region ../../lib/contract/src/props/index.ts
+const activeProps = makeStateNormalizer({
+	state: "active",
+	aria: "aria-current",
+	data: "data-active"
+});
+const disabledProps = makeStateNormalizer({
+	state: "disabled",
+	aria: "aria-disabled",
+	data: "data-disabled"
+});
+const expandedProps = makeStateNormalizer({
+	state: "expanded",
+	aria: "aria-expanded",
+	data: "data-expanded",
+	falseState: "synthesize"
+});
+const invalidProps = makeStateNormalizer({
+	state: "invalid",
+	aria: "aria-invalid",
+	data: "data-invalid"
+});
+const loadingProps = makeStateNormalizer({
+	state: "loading",
+	aria: "aria-busy",
+	data: "data-loading"
+});
+const pressedProps = makeStateNormalizer({
+	state: "pressed",
+	aria: "aria-pressed",
+	data: "data-pressed",
+	falseState: "synthesize"
+});
+const readonlyProps = makeStateNormalizer({
+	state: "readOnly",
+	aria: "aria-readonly",
+	data: "data-readonly"
+});
+const selectedProps = makeStateNormalizer({
+	state: "selected",
+	aria: "aria-selected",
+	data: "data-selected",
+	falseState: "synthesize"
+});
+//#endregion
+//#region ../../lib/contract/src/aria/factories.ts
+/**
+* Builds a correctly-literal-typed `fixable: false` `AriaResult`. Exists so a rule author can
+* extract shared branch logic (severity/attribute/message computed once, reused across multiple
+* `return`s) without TypeScript silently widening `valid: false`/`fixable: false` to `boolean`
+* the moment those values leave an object-literal-in-return-position — the widening only happens
+* on plain object literals; a function's declared return type narrows unconditionally.
+*/
+function invalidWithoutFix(input) {
+	return {
+		valid: false,
+		fixable: false,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic }
+	};
+}
+/** Same as {@link invalidWithoutFix}, for the `fixable: true` branch — requires a `fix`. */
+function invalidWithFix(input) {
+	return {
+		valid: false,
+		fixable: true,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic },
+		fix: input.fix
+	};
+}
+function removeProp(props, key) {
+	const next = { ...props };
+	delete next[key];
+	return next;
+}
+/**
+* Builds an `AriaFix` that strips a single attribute — the shape `dangerousHrefRule`-style
+* "strip this attribute when it's dangerous/redundant" rules need. A no-op (`applied: false`) when
+* the attribute isn't present, so applying the fix twice (or applying it when nothing triggered it)
+* is always safe. Frozen — a fix is a value object; nothing should mutate `kind`/`attribute`/`apply`
+* after construction.
+*/
+function removeAttributeFix(attribute) {
+	return Object.freeze({
+		kind: "removeAttribute",
+		attribute,
+		apply: ({ props }) => {
+			if (!(attribute in props)) return {
+				applied: false,
+				next: props
+			};
+			return {
+				applied: true,
+				next: removeProp(props, attribute),
+				previous: props
+			};
+		}
+	});
+}
+function defineRuleMetadata(rule, metadata) {
+	const descriptors = {};
+	for (const key of Object.keys(metadata)) descriptors[key] = {
+		value: metadata[key],
+		enumerable: false
+	};
+	Object.defineProperties(rule, descriptors);
+	return rule;
+}
+/**
+* Convenience factory for the single most common `enforcement.aria`/`enforcement.rules` shape:
+* "strip this attribute when some condition on the element's own props holds" — covers
+* security-style guards (a dangerous URL scheme on `href`) and redundant-attribute rules alike,
+* without hand-writing the rule function, the `AriaFix`, and the `invalidWithFix` call each time.
+* A rule with no fix (a warn-only advisory) still needs the raw `AriaRule` shape directly — this
+* factory is deliberately scoped to the strip-on-match case, not a general rule builder.
+*/
+function createRemoveAttributeRule(attribute, options) {
+	const { when, severity = "warning", message, diagnostic, readsProps, tags } = options;
+	const fix = removeAttributeFix(attribute);
+	const rule = (context) => {
+		if (!when(context)) return [];
+		return [invalidWithFix({
+			severity,
+			attribute,
+			...isDefined(message) && { message },
+			...isDefined(diagnostic) && { diagnostic: diagnostic(context) },
+			fix
+		})];
+	};
+	return defineRuleMetadata(rule, {
+		...isDefined(readsProps) && { readsProps },
+		...isDefined(tags) && { tags }
+	});
+}
+//#endregion
+//#region ../core/src/state/contracts.ts
+function stateContract(props) {
+	return { props };
+}
+const activeContract = stateContract([activeProps]);
+const disabledContract = stateContract([disabledProps]);
+const expandedContract = stateContract([expandedProps]);
+const invalidContract = stateContract([invalidProps]);
+const loadingContract = stateContract([loadingProps]);
+const pressedContract = stateContract([pressedProps]);
+const readonlyContract = stateContract([readonlyProps]);
+const selectedContract = stateContract([selectedProps]);
+//#endregion
+//#region ../core/src/state/merge-contracts.ts
+function mergeContracts(...contracts) {
+	const props = contracts.flatMap((c) => c.props ?? []);
+	const aria = contracts.flatMap((c) => c.aria ?? []);
+	const rules = contracts.flatMap((c) => c.rules ?? []);
+	const children = contracts.flatMap((c) => c.children ?? []);
+	let diagnostics;
+	let allowedAs;
+	iterate.forEach(contracts, (c) => {
+		if (c.diagnostics !== void 0) diagnostics = c.diagnostics;
+		if (c.allowedAs !== void 0) allowedAs = c.allowedAs;
+	});
+	return {
+		...props.length > 0 && { props },
+		...aria.length > 0 && { aria },
+		...rules.length > 0 && { rules },
+		...children.length > 0 && { children },
+		...diagnostics !== void 0 && { diagnostics },
+		...allowedAs !== void 0 && { allowedAs }
+	};
+}
+//#endregion
+export { activeContract, activeProps, createRemoveAttributeRule, disabledContract, disabledProps, expandedContract, expandedProps, invalidContract, invalidProps, invalidWithFix, invalidWithoutFix, loadingContract, loadingProps, makeStateNormalizer, mergeContracts, pressedContract, pressedProps, readonlyContract, readonlyProps, removeAttributeFix, selectedContract, selectedProps };

package/dist/eslint/index.d.ts

@@ -0,0 +1,90 @@
+import { ESLint } from "eslint";
+//#region ../../plugins/eslint/src/rules/no-dead-compound.d.ts
+type Options$4 = [{
+  calleeNames?: string[];
+  reportNonLiteral?: boolean;
+}];
+type MessageIds$3 = 'unknownVariantKey' | 'unknownVariantValue' | 'nonLiteralValue';
+export declare const noDeadCompound: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds$3, Options$4, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-enforcement-without-strict.d.ts
+type Options$3 = [{
+  calleeNames?: string[];
+}];
+export declare const noEnforcementWithoutStrict: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingStrict", Options$3, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-invalid-default.d.ts
+type Options$2 = [{
+  calleeNames?: string[];
+  reportNonLiteral?: boolean;
+}];
+type MessageIds$2 = 'unknownDefaultKey' | 'unknownDefaultValue' | 'nonLiteralValue';
+export declare const noInvalidDefault: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds$2, Options$2, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-invalid-html-nesting.d.ts
+export declare const noInvalidHtmlNesting: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidChild", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-redundant-role.d.ts
+export declare const noRedundantRole: import("@typescript-eslint/utils/ts-eslint").RuleModule<"redundantRole", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/valid-cardinality.d.ts
+type Options$1 = [{
+  calleeNames?: string[];
+}];
+type MessageIds$1 = 'negativeMin' | 'negativeMax' | 'maxLessThanMin';
+export declare const validCardinality: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds$1, Options$1, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/valid-children-config.d.ts
+type Options = [{
+  calleeNames?: string[];
+}];
+type MessageIds = 'multipleFirst' | 'multipleLast' | 'minSumExceedsCapacity';
+export declare const validChildrenConfig: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+//#region ../../plugins/eslint/src/index.d.ts
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: ESLint.Plugin["rules"];
+  configs: {};
+};
+declare const recommended: {
+  readonly name: "@praxis-kit/recommended";
+  readonly plugins: {
+    readonly '@praxis-kit': {
+      meta: {
+        name: string;
+        version: string;
+      };
+      rules: ESLint.Plugin["rules"];
+      configs: {};
+    };
+  };
+  readonly rules: {
+    readonly '@praxis-kit/no-dead-compound': "error";
+    readonly '@praxis-kit/no-enforcement-without-strict': "error";
+    readonly '@praxis-kit/no-invalid-default': "error";
+    readonly '@praxis-kit/no-invalid-html-nesting': "error";
+    readonly '@praxis-kit/no-redundant-role': "warn";
+    readonly '@praxis-kit/valid-cardinality': "error";
+    readonly '@praxis-kit/valid-children-config': "error";
+  };
+};
+//#endregion
+export { plugin as default, plugin, recommended };