@nkardaz/typography-rules 1.0.0

package/dist/api/blacklist.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Internal blacklist implemented as a Trie.
+ *
+ * Supports hierarchical rule disabling:
+ * - Exact match: "/english/math"
+ * - Prefix match: "/english/math" disables "/english/math/*"
+ *
+ * Special rule:
+ * - "*" disables all rules globally
+ *
+ * This structure allows efficient prefix-based rule matching
+ * without scanning a flat Set.
+ */
+export declare function disableRule(rule: string): void;
+/**
+ * Re-enables a previously disabled rule.
+ *
+ * If the rule was globally disabled via "*",
+ * global flag will be cleared.
+ *
+ * Note: removing a prefix rule does not automatically
+ * restore sub-rules if they were individually disabled.
+ *
+ * @param rule Rule path to enable
+ */
+export declare function enableRule(rule: string): void;
+/**
+ * Toggles a rule between enabled and disabled state.
+ *
+ * If rule is currently disabled → it will be enabled.
+ * If rule is enabled → it will be disabled.
+ *
+ * @param rule Rule path to toggle
+ */
+export declare function toggleRule(rule: string): void;
+/**
+ * Checks whether a rule is disabled.
+ *
+ * A rule is considered disabled if:
+ * - global disable flag "*" is active
+ * - any parent rule in the path is disabled
+ * - the rule itself is explicitly disabled
+ *
+ * Example:
+ * "/english/math" disables:
+ * - "/english/math"
+ * - "/english/math/geometry"
+ *
+ * @param rule Rule path to check
+ * @returns true if rule is disabled
+ */
+export declare function isRuleDisabled(rule: string): boolean;
+/**
+ * Checks whether all rules are globally disabled.
+ *
+ * Global disable is represented by "*" rule.
+ *
+ * @returns true if global disable is active
+ */
+export declare function isGloballyDisabled(): boolean;
+/**
+ * Clears the entire rule blacklist.
+ *
+ * This removes:
+ * - all explicitly disabled rules in the Trie
+ * - global disable flag ("*")
+ *
+ * After calling this function, all rules become enabled again
+ * unless re-disabled explicitly.
+ */
+export declare function clearBlacklist(): void;
+//# sourceMappingURL=blacklist.d.ts.map

package/dist/api/htmlNodes.d.ts

@@ -0,0 +1,30 @@
+import type { HtmlNodeSettings, Node } from '@/types';
+import type { Text } from 'mdast';
+import type { MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+/**
+ * Parses a string into a tree of nodes based on a regular expression.
+ * * @param text The input string to parse
+ * @param settings Configuration containing the expression and a node factory function
+ * @returns An array of text and element nodes
+ */
+export declare function htmlNode(text: string, { expression, nodes }?: HtmlNodeSettings): Node[];
+/**
+ * Converts a node structure into an HTML string representation.
+ * * @param node The node to render
+ * @returns The resulting HTML string
+ */
+export declare function renderNode(node: Node): string;
+/**
+ * Renders an array of nodes into a single concatenated HTML string.
+ * * @param nodes Array of nodes to render
+ * @returns The resulting concatenated HTML string
+ */
+export declare function renderNodes(nodes: Node[]): string;
+/**
+ * Transforms a custom node structure into an MDAST (Markdown Abstract Syntax Tree) element,
+ * specifically targeting MDX JSX syntax.
+ * * @param n The node to transform
+ * @returns An MDAST Text or MdxJsxTextElement node
+ */
+export declare function nodeToMdast(n: Node): Text | MdxJsxTextElement;
+//# sourceMappingURL=htmlNodes.d.ts.map

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from './newRule';
+export * from './registerRule';
+export * from './blacklist';
+export * from './rulesInit';
+export * from './htmlNodes';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/newRule.d.ts

@@ -0,0 +1,51 @@
+import type { Rule, RuleFunction } from '@/types';
+/**
+ * Creates a **replace** rule — every match is substituted with a literal string.
+ *
+ * The resulting rule is used in typography pipelines to transform text.
+ *
+ * @param label - Human-readable identifier for the rule
+ * @param rule - RegExp pattern to match against
+ * @param replacement - Literal string used as replacement for every match
+ * @param weight - Priority of the rule (higher = applied later)
+ *
+ * @returns `RegExpReplaceRule`
+ *
+ * @example
+ * newRule('em-dash', /--/g, '-');
+ */
+declare function newRule(label: string, rule: RegExp, replacement: string, weight?: number): Rule;
+/**
+ * Creates a **transform** rule — replacement is computed dynamically from the match.
+ *
+ * The resulting rule is used in typography pipelines to transform text.
+ *
+ * @param label - Human-readable identifier for the rule
+ * @param rule - RegExp pattern to match against
+ * @param transform - Callback receiving the full `RegExpExecArray`; return value replaces the matched substring
+ * @param weight - Priority of the rule (higher = applied later)
+ *
+ * @returns `RegExpTransformRule`
+ *
+ * @example
+ * newRule('wrap-digits', /\d+/g, m => `[${m[0]}]`);
+ */
+declare function newRule(label: string, rule: RegExp, transform: (match: RegExpExecArray) => string, weight?: number): Rule;
+/**
+ * Creates a **function** rule — custom logic with forwarded arguments.
+ *
+ * The resulting rule is used in typography pipelines to transform text.
+ *
+ * @param label - Human-readable identifier for the rule
+ * @param rule - Custom rule function — receives `args` at call time
+ * @param args - Arguments forwarded to the rule function when applied
+ * @param weight - Priority of the rule (higher = applied later)
+ *
+ * @returns `FunctionRule`
+ *
+ * @example
+ * newRule('custom', myRuleFn, ['arg1', 'arg2']);
+ */
+declare function newRule(label: string, rule: RuleFunction, args?: unknown[], weight?: number): Rule;
+export { newRule };
+//# sourceMappingURL=newRule.d.ts.map

package/dist/api/registerRule.d.ts

@@ -0,0 +1,27 @@
+import type { Rule } from '@/types';
+interface LabelTransform {
+    expression: RegExp;
+    replacement: string;
+}
+/**
+ * Registers one or more typography rules for a locale.
+ *
+ * Automatically invalidates the weighted rules cache
+ * for the affected locale and “common”.
+ *
+ * @param locale Locale code (e.g. "en", "de", "fr").
+ * @param rules A sequence of rules[].
+ */
+declare function registerRule(locale: string, ...rules: Rule[]): void;
+/**
+ * Registers rules for a locale, inheriting from a base locale.
+ *
+ * @param locale Locale code to register rules for (e.g. "fr", "de").
+ * @param base Locale code to inherit rules from (e.g. "en").
+ * @param options.label Optional transform applied to each inherited rule's label.
+ * @param options.excludes Rule labels to exclude from the base.
+ * @param rules Additional rules to register on top of the inherited ones.
+ */
+declare function rulesBase(locale: string, base: string, label?: LabelTransform, excludes?: string[], ...rules: Rule[]): void;
+export { registerRule, rulesBase };
+//# sourceMappingURL=registerRule.d.ts.map

package/dist/api/rulesInit.d.ts

@@ -0,0 +1,49 @@
+import type { Rule } from '@/types';
+/**
+ * Default typography transformation rules grouped by locale.
+ *
+ * Each group defines a pipeline of RegExp and functional rules
+ * applied during text normalization and typographic processing.
+ *
+ * Structure:
+ * - common: rules applied to all locales
+ * - ru: Russian-specific typography rules
+ * - en: English-specific typography rules
+ *
+ * Rules include:
+ * - whitespace normalization
+ * - dash and punctuation correction
+ * - smart quotes processing
+ * - currency spacing rules
+ * - ligature substitution
+ */
+declare const defaultTypographyRules: Record<string, Rule[]>;
+declare const defaultMarkupRules: Record<string, Rule[]>;
+/**
+ * Available typography rule groups.
+ *
+ * Represents all supported locale keys in the default ruleset.
+ */
+export type defaultRuleKeys = keyof typeof defaultTypographyRules;
+/**
+ * Runtime list of available typography rule groups.
+ */
+export declare const defaultRuleKeys: (keyof typeof defaultTypographyRules)[];
+/**
+ * Applies default typography rules to the global typography registry.
+ *
+ * If no locale is specified:
+ * - all rule groups are applied
+ *
+ * If locale is specified:
+ * - only that group is applied
+ *
+ * This function initializes the typography pipeline
+ * before processing text transformations.
+ *
+ * @param from Optional locale keys to apply specific rule group
+ */
+export declare function initTypographyRules(...from: (keyof typeof defaultTypographyRules)[]): void;
+export declare function initMarkupRules(...from: (keyof typeof defaultMarkupRules)[]): void;
+export {};
+//# sourceMappingURL=rulesInit.d.ts.map

package/dist/functions/chemNotation.d.ts

@@ -0,0 +1,10 @@
+import type { Node, TagSettings, ChemNotationSettings } from '@/types';
+/**
+ * Parses chemical notation and converts it into MathML-like <mmultiscripts> structures.
+ * * @param text - The input string containing chemical notation syntax
+ * @param settings - Configuration for the marker and wrapper delimiters
+ * @param tagSettings - Optional class name and attributes for the <math> wrapper
+ * @returns An array of nodes including text and <math> nodes
+ */
+export declare function chemNotation(text: string, { marker, wrapper }?: ChemNotationSettings, { className, attrs }?: TagSettings): Node[];
+//# sourceMappingURL=chemNotation.d.ts.map

package/dist/functions/clearSpaces.d.ts

@@ -0,0 +1,16 @@
+import type { ClearSpacesSettings } from '@/types';
+/**
+ * Replaces multiple spaces with a single space.
+ *
+ * @param text - Input text.
+ *
+ * @param spaces - Array of space characters to remove.
+ *
+ * @returns Text with multiple spaces replaced by a single space.
+ *
+ * @example
+ * clearSpaces('a  b  c') // 'a b c'
+ * clearSpaces('a\u2009\u2009b\u2009\u2009c') // 'a\u2009b\u2009c' (thin space)
+ */
+export declare function clearSpaces(text: string, { spaces }?: ClearSpacesSettings): string;
+//# sourceMappingURL=clearSpaces.d.ts.map