@atlaskit/eslint-plugin-design-system 14.2.0 → 14.3.0

package/dist/types/rules/use-latest-xcss-syntax-typography/config/get-config.d.ts

@@ -0,0 +1,2 @@
+import type { RuleConfig } from './types';
+export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;

package/dist/types/rules/use-latest-xcss-syntax-typography/config/patterns.d.ts

@@ -0,0 +1,2 @@
+export declare const PATTERNS: readonly ["restricted-property", "wrapped-token-value", "restricted-capitalisation"];
+export type Pattern = (typeof PATTERNS)[number];

package/dist/types/rules/use-latest-xcss-syntax-typography/config/types.d.ts

@@ -0,0 +1,5 @@
+import type { Pattern } from './patterns';
+export interface RuleConfig {
+    failSilently: boolean;
+    patterns: Pattern[];
+}

package/dist/types/rules/use-latest-xcss-syntax-typography/linters/common.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 export type MetaData = {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-primitives/config/get-config.d.ts

@@ -0,0 +1,2 @@
+import type { RuleConfig } from './types';
+export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;

package/dist/types/rules/use-primitives/config/types.d.ts

@@ -0,0 +1,4 @@
+import type { Pattern } from './valid-patterns';
+export interface RuleConfig {
+    patterns: Pattern[];
+}

package/dist/types/rules/use-primitives/config/valid-patterns.d.ts

@@ -0,0 +1,2 @@
+export declare const VALID_PATTERNS: string[];
+export type Pattern = (typeof VALID_PATTERNS)[number];

package/dist/types/rules/use-primitives/transformers/compiled-styled/index.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type JSXElement, type VariableDeclarator } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../../config';
+import type { RuleConfig } from '../../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-primitives/transformers/css-to-xcss-transformer.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type JSXElement } from 'eslint-codemod-utils';
+export declare const cssToXcssTransformer: (node: JSXElement, context: Rule.RuleContext, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];

package/dist/types/rules/use-primitives/transformers/emotion-css/index.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type JSXElement } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../../config';
+import type { RuleConfig } from '../../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-primitives/transformers/styled-object-to-xcss-tokens.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type ObjectExpression } from 'eslint-codemod-utils';
+export declare const styledObjectToXcssTokens: (styles: ObjectExpression & Partial<Rule.NodeParentExtension>, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];

package/dist/types/rules/use-primitives/transformers/supported-styles-map.d.ts

@@ -0,0 +1,4 @@
+import { spaceTokenMap } from './space-token-map';
+export declare const supportedStylesMap: {
+    [key: string]: typeof spaceTokenMap;
+};

package/dist/types/rules/use-primitives/utils/is-valid-css-properties-to-transform.d.ts

@@ -1,4 +1,4 @@
 import type { Rule } from 'eslint';
 import { type SimpleCallExpression } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 export declare const isValidCssPropertiesToTransform: (node: SimpleCallExpression & Rule.NodeParentExtension, config: RuleConfig) => boolean;

package/dist/types/rules/use-primitives/utils/validate-styles.d.ts

@@ -1,3 +1,3 @@
 import { type CallExpression } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 export declare const validateStyles: (node: CallExpression, config: RuleConfig) => boolean;

package/dist/types/rules/use-primitives-text/config/get-config.d.ts

@@ -0,0 +1,2 @@
+import type { RuleConfig } from './types';
+export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;

package/dist/types/rules/use-primitives-text/config/patterns.d.ts

@@ -0,0 +1,2 @@
+export type Pattern = (typeof PATTERNS)[number];
+export declare const PATTERNS: string[];

package/dist/types/rules/use-primitives-text/config/{index.d.ts → types.d.ts}

@@ -1,5 +1,4 @@
-export declare const PATTERNS: string[];
-type Pattern = (typeof PATTERNS)[number];
+import { type Pattern } from './patterns';
 export interface RuleConfig {
     failSilently: boolean;
     patterns: Pattern[];
@@ -7,5 +6,3 @@ export interface RuleConfig {
     enableUnsafeAutofix: boolean;
     enableUnsafeReport: boolean;
 }
-export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;
-export {};

package/dist/types/rules/use-primitives-text/transformers/add-color-inherit-attribute-fix.d.ts

@@ -1,4 +1,4 @@
 import type { Rule } from 'eslint';
 import { type JSXElement } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 export declare function addColorInheritAttributeFix(node: JSXElement, config: RuleConfig, fixer: Rule.RuleFixer): Rule.Fix | undefined;

package/dist/types/rules/use-primitives-text/transformers/common.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 export type MetaData = {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-should-render-to-parent/add-prop.d.ts

@@ -0,0 +1 @@
+export declare const addProp: 'Add `shouldRenderToParent` prop.';

package/dist/types/rules/use-should-render-to-parent/index.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 export declare const RULE_NAME = "use-should-render-to-parent";
-export declare const addProp: 'Add `shouldRenderToParent` prop.';
-export declare const setPropToTrue: 'Set `shouldRenderToParent` prop to `true`.';
 declare const rule: Rule.RuleModule;
 export default rule;
+export { addProp } from './add-prop';
+export { setPropToTrue } from './set-prop-to-true';

package/dist/types/rules/use-should-render-to-parent/set-prop-to-true.d.ts

@@ -0,0 +1 @@
+export declare const setPropToTrue: 'Set `shouldRenderToParent` prop to `true`.';

package/dist/types/rules/use-simple-form/index.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-export declare const topLevelAttributeNames: string[];
 export declare const convertForm = "Convert form to simple form";
 declare const rule: Rule.RuleModule;
 export default rule;
+export { topLevelAttributeNames } from './top-level-attribute-names';

package/dist/types/rules/use-simple-form/top-level-attribute-names.d.ts

@@ -0,0 +1 @@
+export declare const topLevelAttributeNames: string[];

package/dist/types/rules/use-tokens-typography/config/get-config.d.ts

@@ -0,0 +1,2 @@
+import type { RuleConfig } from './types';
+export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;

package/dist/types/rules/use-tokens-typography/config/rule-schema.d.ts

@@ -0,0 +1,2 @@
+import type { JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
+export declare const ruleSchema: JSONSchema4;

package/dist/{types-ts4.5/rules/use-tokens-typography/config/index.d.ts → types/rules/use-tokens-typography/config/types.d.ts}

@@ -1,10 +1,7 @@
-import type { JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
 type Pattern = 'style-object' | 'font-weight' | 'font-family' | 'untokenized-properties' | 'banned-properties' | 'restricted-capitalisation';
 export type RuleConfig = {
     failSilently: boolean;
     enableUnsafeAutofix: boolean;
     patterns: Pattern[];
 };
-export declare const ruleSchema: JSONSchema4;
-export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;
 export {};

package/dist/types/rules/use-tokens-typography/default-font-weight.d.ts

@@ -0,0 +1 @@
+export declare const defaultFontWeight: string;

package/dist/types/rules/use-tokens-typography/find-font-weight-token-for-value.d.ts

@@ -0,0 +1,2 @@
+import type { TokenValueMap } from './types';
+export declare function findFontWeightTokenForValue(fontWeight: string, tokens?: TokenValueMap[]): TokenValueMap | undefined;

package/dist/types/rules/use-tokens-typography/find-typography-token-for-values.d.ts

@@ -0,0 +1,2 @@
+import type { TokenValueMap } from './types';
+export declare function findTypographyTokenForValues(fontSize: string, lineHeight?: string): TokenValueMap[];

package/dist/types/rules/use-tokens-typography/font-weight-map.d.ts

@@ -0,0 +1,2 @@
+import type { FontWeightMap } from './types';
+export declare const fontWeightMap: FontWeightMap;

package/dist/types/rules/use-tokens-typography/font-weight-tokens.d.ts

@@ -0,0 +1,2 @@
+import type { TokenValueMap } from './types';
+export declare const fontWeightTokens: TokenValueMap[];

package/dist/types/rules/use-tokens-typography/get-token-property.d.ts

@@ -0,0 +1,2 @@
+import { type Property, type StringableASTNode } from 'eslint-codemod-utils';
+export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback?: string, isFallbackMember?: boolean): StringableASTNode<Property>;

package/dist/types/rules/use-tokens-typography/transformers/banned-properties.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type Property } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/transformers/font-family.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type Property } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/transformers/font-weight.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type Property } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/transformers/restricted-capitalisation.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type Property } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/transformers/style-object.d.ts

@@ -1,7 +1,7 @@
 import type { Rule } from 'eslint';
 import { type ImportDeclaration, type ObjectExpression, type Property, type StringableASTNode } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
-import { type TokenValueMap } from '../utils';
+import type { RuleConfig } from '../config/types';
+import type { TokenValueMap } from '../types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/transformers/untokenized-properties.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
 import { type Property } from 'eslint-codemod-utils';
-import type { RuleConfig } from '../config';
+import type { RuleConfig } from '../config/types';
 interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;

package/dist/types/rules/use-tokens-typography/types.d.ts

@@ -0,0 +1,15 @@
+export type TokenValueMap = {
+    tokenName: string;
+    tokenValue: string;
+    values: {
+        fontSize?: string;
+        fontWeight?: string;
+        lineHeight?: string;
+    };
+};
+export type FontWeightMap = {
+    regular: string;
+    medium: string;
+    semibold: string;
+    bold: string;
+};

package/dist/types/rules/use-tokens-typography/typography-value-to-token.d.ts

@@ -0,0 +1,2 @@
+import type { TokenValueMap } from './types';
+export declare const typographyValueToToken: TokenValueMap[];

package/dist/types/rules/use-visually-hidden/count-matching-key-values.d.ts

@@ -0,0 +1,6 @@
+type KeyValue = {
+    key: string;
+    value: string;
+};
+export declare const countMatchingKeyValues: (styleEntries: KeyValue[]) => number;
+export {};

package/dist/types/rules/use-visually-hidden/get-object-likeness.d.ts

@@ -0,0 +1,9 @@
+import { type ObjectExpression } from 'eslint-codemod-utils';
+/**
+ * Given a node, translate the node into css key-value pairs and
+ * compare the output to the reference styles required to make a
+ * visually hidden element.
+ *
+ * @returns {number} A fraction between 0-1 depending on the object's likeness.
+ */
+export declare const getObjectLikeness: (node: ObjectExpression) => number;

package/dist/types/rules/use-visually-hidden/reference-object.d.ts

@@ -0,0 +1,11 @@
+export type ReferenceObject = typeof referenceObject;
+export declare const referenceObject: {
+    width: string;
+    height: string;
+    padding: string;
+    position: string;
+    border: string;
+    clip: string;
+    overflow: string;
+    whiteSpace: string;
+};

package/dist/types/rules/utils/create-lint-rule.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from 'eslint';
+import { type LintRule } from '@atlaskit/eslint-utils/create-rule';
+/**
+ * Tiny wrapped over the ESLint rule module type that ensures
+ * there is a docs link to our ESLint plugin documentation page,
+ * as well as improving type support.
+ */
+export declare const createLintRule: (rule: LintRule) => Rule.RuleModule;

package/dist/types/rules/utils/create-no-tagged-template-expression-rule/create-no-tagged-template-expression-rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from 'eslint';
+import { type SupportedNameChecker } from '@atlaskit/eslint-utils/is-supported-import';
+type RuleModule = Rule.RuleModule;
+export declare const createNoTaggedTemplateExpressionRule: (isUsage: SupportedNameChecker, messageId: string) => RuleModule["create"];
+export {};

package/dist/types/rules/utils/create-no-tagged-template-expression-rule/no-tagged-template-expression-rule-schema.d.ts

@@ -0,0 +1,2 @@
+import type { JSONSchema4 } from 'json-schema';
+export declare const noTaggedTemplateExpressionRuleSchema: JSONSchema4;

package/dist/types/rules/utils/create-rule.d.ts

@@ -1,6 +1,4 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-import type { Rule } from 'eslint';
-import { type LintRule } from '@atlaskit/eslint-utils/create-rule';
 /**
  * We are moving to our own small abstraction to create a lint rule that we have the power
  * to change and mold to our own needs.
@@ -11,9 +9,3 @@ import { type LintRule } from '@atlaskit/eslint-utils/create-rule';
  * @deprecated
  */
 export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds>>) => ESLintUtils.RuleModule<MessageIds, Options>;
-/**
- * Tiny wrapped over the ESLint rule module type that ensures
- * there is a docs link to our ESLint plugin documentation page,
- * as well as improving type support.
- */
-export declare const createLintRule: (rule: LintRule) => Rule.RuleModule;

package/dist/types/rules/utils/get-rule-url.d.ts

@@ -0,0 +1 @@
+export declare function getRuleUrl(ruleName: string): string;

package/dist/types/rules/utils/includes-hard-coded-color.d.ts

@@ -0,0 +1 @@
+export declare const includesHardCodedColor: (raw: string) => boolean;

package/dist/types/rules/utils/is-color-css-property-name.d.ts

@@ -0,0 +1 @@
+export declare const isColorCssPropertyName: (value: string) => boolean;

package/dist/types/rules/utils/is-css-in-js-call-node.d.ts

@@ -0,0 +1,2 @@
+import { type CallExpression, type Expression } from 'eslint-codemod-utils';
+export declare const isCssInJsCallNode: (node?: Expression | null) => node is CallExpression;

package/dist/types/rules/utils/is-css-in-js-object-node.d.ts

@@ -0,0 +1,2 @@
+import { type CallExpression, type Expression } from 'eslint-codemod-utils';
+export declare const isCssInJsObjectNode: (node?: Expression | null) => node is CallExpression;

package/dist/types/rules/utils/is-decendant-of-style-block.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const isDecendantOfStyleBlock: (node: Rule.Node) => boolean;

package/dist/types/rules/utils/is-deprecated-import-config.d.ts

@@ -0,0 +1,2 @@
+import type { DeprecatedImportConfig, DeprecatedJSXAttributeConfig } from './types';
+export declare const isDeprecatedImportConfig: (config: DeprecatedImportConfig | DeprecatedJSXAttributeConfig) => config is DeprecatedImportConfig;

package/dist/types/rules/utils/is-deprecated-jsx-attribute-config.d.ts

@@ -0,0 +1,2 @@
+import type { DeprecatedImportConfig, DeprecatedJSXAttributeConfig } from './types';
+export declare const isDeprecatedJSXAttributeConfig: (config: DeprecatedImportConfig | DeprecatedJSXAttributeConfig) => config is DeprecatedJSXAttributeConfig;

package/dist/types/rules/utils/is-hard-coded-color.d.ts

@@ -0,0 +1 @@
+export declare const isHardCodedColor: (value: string) => boolean;

package/dist/types/rules/utils/is-legacy-color.d.ts

@@ -0,0 +1 @@
+export declare const isLegacyColor: (value: string) => boolean;

package/dist/types/rules/utils/is-legacy-named-color.d.ts

@@ -0,0 +1 @@
+export declare const isLegacyNamedColor: (value: string) => boolean;

package/dist/types/rules/utils/named-colors.d.ts

@@ -0,0 +1 @@
+export declare const namedColors: Set<string>;

package/dist/types/rules/utils/types.d.ts

@@ -19,8 +19,6 @@ export type DeprecatedImportConfigEntry = {
     }[];
     unfixable?: boolean;
 };
-export declare const isDeprecatedImportConfig: (config: DeprecatedImportConfig | DeprecatedJSXAttributeConfig) => config is DeprecatedImportConfig;
-export declare const isDeprecatedJSXAttributeConfig: (config: DeprecatedImportConfig | DeprecatedJSXAttributeConfig) => config is DeprecatedJSXAttributeConfig;
 export type Fix = {
     range: [number, number];
     text: string;

package/dist/types-ts4.5/ast-nodes/jsx-element-helper.d.ts

@@ -0,0 +1,23 @@
+import type { Rule } from 'eslint';
+import { type JSXAttribute, type JSXElement, type JSXFragment, type JSXSpreadAttribute } from 'eslint-codemod-utils';
+export declare const JSXElementHelper: {
+    /**
+     * Names of JSXElements can be any of:
+     * `<Component></Component>` - (JSXIdentifier)
+     * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is a namespace (JSXNamespacedName)
+     * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is an object (JSXMemberExpression)
+     *
+     * getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
+     * e.g. Getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
+     * `getName` does not currently have this functionality. Add it if you need it.
+     */
+    getName(node: JSXElement): string;
+    updateName(node: JSXElement, newName: string, fixer: Rule.RuleFixer): Rule.Fix[];
+    isSelfClosing(node: JSXElement): boolean;
+    getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
+    getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
+    containsSpreadAttributes(node: JSXElement): boolean;
+    addAttribute(node: JSXElement, name: string, value: string, fixer: Rule.RuleFixer): Rule.Fix;
+    getChildren(node: JSXElement | JSXFragment): JSXElement["children"];
+    hasAllowedAttrsOnly(node: JSXElement, allowedProps: string[]): boolean;
+};

package/dist/types-ts4.5/common/token-maps.partial.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS SECTION WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::8d2e42e9308a5216d1de97408fbb692d>>
+ * @codegen <<SignedSource::d35b67b5e07f9d069f3b0cbdb4cf8e77>>
  * @codegenId spacing
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen-token-maps
  * @codegenDependency ../../../tokens/src/artifacts/tokens-raw/atlassian-spacing.tsx <<SignedSource::535518e7add48ef24f526d0904f70060>>

package/dist/types-ts4.5/rules/ensure-design-token-usage/em-to-pixels.d.ts

@@ -0,0 +1 @@
+export declare const emToPixels: <T extends unknown>(value: T, fontSize: number | null | undefined) => number | T | null;

package/dist/types-ts4.5/rules/ensure-design-token-usage/find-token-name-by-property-value.d.ts

@@ -0,0 +1 @@
+export declare function findTokenNameByPropertyValue(propertyName: string, value: string): string | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-domains-for-property.d.ts

@@ -0,0 +1,13 @@
+import type { Domains } from './types';
+/**
+ * Returns an array of domains that are relevant to the provided property based on the rule options.
+ * @param propertyName camelCase CSS property
+ * @param targetOptions Array containing the types of properties that should be included in the rule.
+ * @example
+ * ```
+ * propertyName: padding, targetOptions: ['spacing'] -> returns ['spacing']
+ * propertyName: backgroundColor, targetOptions: ['spacing'] -> returns []
+ * propertyName: backgroundColor, targetOptions: ['color', 'spacing'] -> returns ['color']
+ * ```
+ */
+export declare function getDomainsForProperty(propertyName: string, targetOptions: Domains): Domains;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-font-size-value-in-scope.d.ts

@@ -0,0 +1,2 @@
+import { type ProcessedCSSLines } from './types';
+export declare function getFontSizeValueInScope(cssProperties: ProcessedCSSLines): number | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-property-node-from-parent.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type ObjectExpression, type Property, type SpreadElement } from 'eslint-codemod-utils';
+export declare function getPropertyNodeFromParent(property: string, parentNode: ObjectExpression & Rule.NodeParentExtension): Property | SpreadElement | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-token-node-for-value.d.ts

@@ -0,0 +1,12 @@
+import { type SimpleCallExpression, type StringableASTNode } from 'eslint-codemod-utils';
+/**
+ * Returns a token node for a given value including fallbacks.
+ * @param propertyName camelCase CSS property
+ * @param value string representing pixel value, or font family, or number representing font weight
+ * @example
+ * ```
+ * propertyName: padding, value: '8px' => token('space.100', '8px')
+ * propertyName: fontWeight, value: 400 => token('font.weight.regular', '400')
+ * ```
+ */
+export declare function getTokenNodeForValue(propertyName: string, value: string): StringableASTNode<SimpleCallExpression>;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-token-replacement.d.ts

@@ -0,0 +1,8 @@
+import type { SimpleCallExpression, StringableASTNode } from 'eslint-codemod-utils';
+/**
+ * Returns a stringifiable node with the token expression corresponding to its matching token.
+ * If no token found for the pair the function returns undefined.
+ * @param propertyName string camelCased css property.
+ * @param value The computed value e.g '8px' -> '8'.
+ */
+export declare function getTokenReplacement(propertyName: string, value: string): StringableASTNode<SimpleCallExpression> | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-token-suggestion.d.ts

@@ -0,0 +1,7 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+type Suggestion = {
+    shouldReturnSuggestion: boolean;
+} & Rule.SuggestionReportDescriptor;
+export declare const getTokenSuggestion: (node: Rule.Node, reference: string, config: RuleConfig) => Suggestion[];
+export {};

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-value-for-property-node.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type Property, type SpreadElement } from 'eslint-codemod-utils';
+export declare function getValueForPropertyNode(propertyNode: Property | SpreadElement, context: Rule.RuleContext): string | number | null | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-value-from-shorthand.d.ts

@@ -0,0 +1 @@
+export declare const getValueFromShorthand: (str: unknown) => (string | number)[];

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-value-from-template-literal-raw.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { type EslintNode } from 'eslint-codemod-utils';
+/**
+ * @example
+ * ```js
+ * `2 ${variable} 0`
+ *
+ * // results in [2, NaN, 0]
+ * ```
+ * ```js
+ * const variable = 4;
+ * `2 ${variable} 0`
+ *
+ * // results in [2, 4, 0]
+ * ```
+ */
+export declare const getValueFromTemplateLiteralRaw: (node: EslintNode, context: Rule.RuleContext) => string[] | string | null;

package/dist/types-ts4.5/rules/ensure-design-token-usage/get-value.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type EslintNode } from 'eslint-codemod-utils';
+export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | (string | number)[] | null | undefined;

package/dist/types-ts4.5/rules/ensure-design-token-usage/index.d.ts

@@ -1,6 +1,5 @@
 import type { Rule } from 'eslint';
 import type { RuleConfig } from './types';
-declare const createWithConfig: (initialConfig: RuleConfig) => Rule.RuleModule['create'];
+export declare const createWithConfig: (initialConfig: RuleConfig) => Rule.RuleModule['create'];
 declare const rule: Rule.RuleModule;
 export default rule;
-export { createWithConfig };

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-border-size-property.d.ts

@@ -0,0 +1 @@
+export declare function isBorderSizeProperty(propertyName: string): boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-calc.d.ts

@@ -0,0 +1 @@
+export declare const isCalc: (value: string | number | boolean | RegExp | null | undefined | any[] | bigint) => boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-radius-property.d.ts

@@ -0,0 +1 @@
+export declare function isRadiusProperty(propertyName: string): boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-shape-property.d.ts

@@ -0,0 +1 @@
+export declare function isShapeProperty(propertyName: string): boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-spacing-property.d.ts

@@ -0,0 +1 @@
+export declare const isSpacingProperty: (propertyName: string) => boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/is-valid-spacing-value.d.ts

@@ -0,0 +1 @@
+export declare const isValidSpacingValue: (value: string | number | boolean | RegExp | null | undefined | any[] | bigint, fontSize?: number | null | undefined) => boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/lint-jsx-identifier-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXIdentifierForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types-ts4.5/rules/ensure-design-token-usage/lint-jsx-literal-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXLiteralForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types-ts4.5/rules/ensure-design-token-usage/lint-jsx-member-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXMemberForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types-ts4.5/rules/ensure-design-token-usage/lint-object-for-color.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+import { type Property } from 'eslint-codemod-utils';
+import type { RuleConfig } from './types';
+export declare const lintObjectForColor: (propertyNode: Property, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types-ts4.5/rules/ensure-design-token-usage/lint-template-identifier-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintTemplateIdentifierForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;