@nkardaz/typography-rules 1.0.0

package/dist/style/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/style/main.css

@@ -0,0 +1,16 @@
+/* src/style/main.css */
+.\@nkardaz-typography-ruby {
+  &.--alternate {
+    -webkit-ruby-position: alternate;
+    ruby-position: alternate;
+  }
+  &.--over {
+    -webkit-ruby-position: over;
+    ruby-position: over;
+  }
+  &.--under {
+    -webkit-ruby-position: under;
+    ruby-position: under;
+  }
+}
+/*# sourceMappingURL=main.css.map */

package/dist/types.d.ts

@@ -0,0 +1,223 @@
+import type { Spaces } from '@/glyphs';
+/**
+ * Base configuration for all typography rules.
+ *
+ * Provides shared properties such as execution priority.
+ *
+ * @property weight - Optional execution weight used for sorting rules.
+ * Lower values are executed earlier.
+ */
+export interface BaseRule {
+    label: string;
+    weight?: number;
+}
+/**
+ * Typography rule that performs direct string replacement using RegExp.
+ *
+ * Matches a pattern and replaces it with a static string value.
+ *
+ * @property kind - Rule type identifier ("replace")
+ * @property rule - Regular expression used for matching text
+ * @property replacement - Replacement string applied to matches
+ */
+export type RegExpReplaceRule = BaseRule & {
+    kind: 'replace';
+    rule: RegExp;
+    replacement: string;
+};
+/**
+ * Typography rule that transforms matched RegExp results dynamically.
+ *
+ * Unlike replace rules, transformation logic is computed per match.
+ *
+ * @property kind - Rule type identifier ("transform")
+ * @property rule - Regular expression used for matching text
+ * @property transform - Function that returns replacement string for each match
+ */
+export type RegExpTransformRule = BaseRule & {
+    kind: 'transform';
+    rule: RegExp;
+    transform: (match: RegExpExecArray) => string;
+};
+/**
+ * Typography rule based on a custom processing function.
+ *
+ * Used for complex transformations that cannot be expressed with RegExp.
+ *
+ * @property label - Descriptive name of the function rule
+ * @property kind - Rule type identifier ("function")
+ * @property rule - Function applied to full text input
+ * @property args - Optional arguments passed to the rule function
+ */
+export type FunctionRule<TArgs extends unknown[] = unknown[], TFn extends (text: string, ...args: TArgs) => string = (text: string, ...args: TArgs) => string> = BaseRule & {
+    label: string;
+    kind: 'function';
+    rule: TFn;
+    args: TArgs;
+};
+/**
+ * Typography rule that transforms RegExp matches into DOM/Tree nodes.
+ *
+ * @property label - Descriptive name of the node rule
+ * @property kind - Rule type identifier ("node")
+ * @property rule - Regular expression used for matching text
+ * @property nodes - Function that maps a RegExp match to a Node structure
+ */
+export type NodeFunctionRule = BaseRule & {
+    label: string;
+    kind: 'node';
+    rule: RegExp;
+    nodes: (match: RegExpExecArray) => Node;
+};
+/**
+ * Generic typography processing function signature.
+ *
+ * Accepts a text input and optional additional arguments,
+ * and returns a transformed string or a set of nodes.
+ */
+export type RuleFunction = (text: string, ...args: never[]) => string | Node[];
+/**
+ * Union type representing all available typography rule variants.
+ *
+ * Includes:
+ * - RegExp-based replacement rules
+ * - RegExp-based transform rules
+ * - Function-based rules
+ * - Node-based rules
+ */
+export type Rule = RegExpReplaceRule | RegExpTransformRule | FunctionRule | NodeFunctionRule;
+/**
+ * Represents a basic text leaf node in the document structure.
+ *
+ * @property type - Node discriminator ("text")
+ * @property value - The raw text content
+ */
+export interface TextNode {
+    type: 'text';
+    value: string;
+}
+/**
+ * Represents an element node containing children in the document structure.
+ *
+ * @property type - The element tag or identifier
+ * @property className - Optional CSS class for the element
+ * @property attrs - Optional key-value map of HTML attributes
+ * @property children - Array of child nodes
+ */
+export interface ElementNode {
+    type: string;
+    className?: string;
+    attrs?: Record<string, string>;
+    children: Node[];
+    data?: Record<string, boolean | string | number>;
+}
+/**
+ * Union type representing a node within the document tree.
+ */
+export type Node = TextNode | ElementNode;
+/**
+ * Configuration for smart quote transformation.
+ *
+ * Defines outer and inner quotation marks used during nesting.
+ *
+ * @property outer - Primary quote pair [opening, closing]
+ * @property inner - Nested quote pair [opening, closing]
+ */
+export interface QuoteSettings {
+    outer?: [string, string];
+    inner?: [string, string];
+}
+/**
+ * Configuration for numeric spacing rules.
+ *
+ * Controls how spacing is applied inside numeric expressions.
+ *
+ * @property minLength - Minimum digit length required to apply spacing
+ * @property separateFloat - Whether to format fractional parts separately
+ * @property separator - Character used as a spacing separator
+ */
+export interface NumberSpaceSettings {
+    minLength?: number;
+}
+/**
+ * Configuration for space removal rules.
+ *
+ * @property spaces - Array of space characters to remove
+ */
+export interface ClearSpacesSettings {
+    spaces?: Spaces[] | string[];
+}
+/**
+ * Configuration for runt handling.
+ *
+ * @property threshold - Threshold value for runt detection
+ * @property space - Space character used for runt replacement
+ * @property minLineLength - Minimum line length for runt detection
+ */
+export interface RuntSettings {
+    threshold?: number;
+    space?: Spaces | string;
+    minLineLength?: number;
+}
+/**
+ * Configuration for rules that convert text matches into HTML structures.
+ *
+ * @property expression - RegExp used to identify target text
+ * @property nodes - Factory function to generate Node structures from matches
+ */
+export interface HtmlNodeSettings {
+    expression?: RegExp;
+    nodes?: (match: RegExpExecArray) => Node;
+}
+/**
+ * Base configuration for text wrappers.
+ *
+ * @property marker - String used to identify the wrap boundaries
+ * @property wrapper - The opening and closing strings to wrap text with
+ */
+export interface WrapperBaseSettings {
+    marker?: string;
+    wrapper?: [string, string];
+}
+/**
+ * Settings for wrapping text within specific HTML tags.
+ *
+ * @property tag - The HTML tag to use for wrapping
+ */
+export interface WrapWithTagsSettings extends WrapperBaseSettings {
+    tag?: string;
+}
+/**
+ * Settings for wrapping text matched by a custom RegExp into an HTML tag.
+ *
+ * @property expression - RegExp used to identify target text
+ * @property tag - The HTML tag to use for wrapping
+ * @property placement - Optional template string defining where the tag is inserted.
+ * Uses `$1`, `$2`, etc. as capture group references and `<TAG>...</TAG>` to mark
+ * the wrapped region. When omitted, the entire match is wrapped.
+ * Example: `'$1<TAG>$2</TAG>'` wraps only the second capture group.
+ */
+export interface WrapWithTagExpressionSettings {
+    expression: RegExp;
+    tag?: string;
+    placement?: string;
+}
+/**
+ * Settings for ruby annotation text formatting.
+ */
+export type RubyTextSettings = WrapperBaseSettings;
+/**
+ * Settings for chemical notation formatting.
+ */
+export type ChemNotationSettings = WrapperBaseSettings;
+/**
+ * General configuration for HTML tag output.
+ *
+ * @property className - CSS class to apply to the generated tag
+ * @property attrs - Additional HTML attributes for the generated tag
+ */
+export interface TagSettings {
+    className?: string;
+    attrs?: Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/typography/aliases.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Creates a normalized alias map with utility methods.
+ * All keys and values are automatically lowercased on creation.
+ *
+ * @param map - An object where each key is a root alias and its value is an array of alternative names.
+ * @returns A Proxy object providing direct key access and alias resolution methods.
+ *
+ * @example
+ * const ALIAS = createAlias({
+ *   en: ['en-US', 'English'],
+ *   ru: ['ru-RU', 'Russian'],
+ * });
+ *
+ * ALIAS.en                  // ['en-us', 'english']
+ * ALIAS.resolve('English')  // 'en'
+ * ALIAS.has('ru-RU')        // true
+ */
+export declare function createAlias<T extends Record<string, string[]>>(map: T): {
+    /**
+     * Checks whether an alias exists in the map,
+     * either as a root key or as an alternative name.
+     *
+     * @param alias - The alias to look up (case-insensitive).
+     * @returns `true` if the alias is found, `false` otherwise.
+     *
+     * @example
+     * ALIAS.has('English') // true
+     * ALIAS.has('fr')      // false
+     */
+    has(alias: string): boolean;
+    /**
+     * Resolves an alias to its root key.
+     *
+     * @param alias - The alias to resolve (case-insensitive).
+     * @returns The root key if found, `undefined` otherwise.
+     *
+     * @example
+     * ALIAS.resolve('Russian') // 'ru'
+     * ALIAS.resolve('ru-RU')   // 'ru'
+     * ALIAS.resolve('fr')      // undefined
+     */
+    resolve(alias: string): string | undefined;
+    /**
+     * Adds one or more alternative names to an existing or new root key.
+     * All values are automatically lowercased.
+     *
+     * @param root - The root key to add aliases to.
+     * @param aliases - One or more alternative names to register.
+     *
+     * @example
+     * ALIAS.push('ru', 'Рус', 'ру')
+     * ALIAS.ru // ['ru-ru', 'russian', 'русский', 'рус', 'ру']
+     */
+    push(root: string, ...aliases: string[]): void;
+    /**
+     * Normalizes one or more strings to lowercase.
+     *
+     * @param alias - One or more strings to normalize.
+     * @returns An array of lowercased strings.
+     *
+     * @example
+     * ALIAS.normalize('English', 'RU-RU') // ['english', 'ru-ru']
+     */
+    normalize(...alias: string[]): string[];
+} & { [K in keyof T]: string[]; };
+/**
+ * Global alias map for supported locales.
+ *
+ * Provides normalized access to locale identifiers and their alternatives.
+ * All lookups are case-insensitive.
+ *
+ * @example
+ * ALIAS.ru                  // ['ru-ru', 'russian', 'русский']
+ * ALIAS.resolve('Русский')  // 'ru'
+ * ALIAS.has('Old English')  // true
+ */
+export declare const ALIAS: {
+    /**
+     * Checks whether an alias exists in the map,
+     * either as a root key or as an alternative name.
+     *
+     * @param alias - The alias to look up (case-insensitive).
+     * @returns `true` if the alias is found, `false` otherwise.
+     *
+     * @example
+     * ALIAS.has('English') // true
+     * ALIAS.has('fr')      // false
+     */
+    has(alias: string): boolean;
+    /**
+     * Resolves an alias to its root key.
+     *
+     * @param alias - The alias to resolve (case-insensitive).
+     * @returns The root key if found, `undefined` otherwise.
+     *
+     * @example
+     * ALIAS.resolve('Russian') // 'ru'
+     * ALIAS.resolve('ru-RU')   // 'ru'
+     * ALIAS.resolve('fr')      // undefined
+     */
+    resolve(alias: string): string | undefined;
+    /**
+     * Adds one or more alternative names to an existing or new root key.
+     * All values are automatically lowercased.
+     *
+     * @param root - The root key to add aliases to.
+     * @param aliases - One or more alternative names to register.
+     *
+     * @example
+     * ALIAS.push('ru', 'Рус', 'ру')
+     * ALIAS.ru // ['ru-ru', 'russian', 'русский', 'рус', 'ру']
+     */
+    push(root: string, ...aliases: string[]): void;
+    /**
+     * Normalizes one or more strings to lowercase.
+     *
+     * @param alias - One or more strings to normalize.
+     * @returns An array of lowercased strings.
+     *
+     * @example
+     * ALIAS.normalize('English', 'RU-RU') // ['english', 'ru-ru']
+     */
+    normalize(...alias: string[]): string[];
+} & {
+    ru: string[];
+    en: string[];
+    ang: string[];
+};
+//# sourceMappingURL=aliases.d.ts.map

package/dist/typography/expressions/common.d.ts

@@ -0,0 +1,29 @@
+export declare const PARTS: {
+    readonly numerals: string;
+    readonly interNumber: string;
+    readonly walletSymbols: string;
+    readonly walletISO: string;
+    readonly leftBrackets: string;
+    readonly rightBrackets: string;
+    readonly percentLike: string;
+    readonly expressivePunctuation: string;
+    readonly number: string;
+};
+export declare const EXPRESSIONS: {
+    readonly plusMinus: RegExp;
+    readonly minusPlus: RegExp;
+    readonly sectionNumeral: RegExp;
+    readonly percentValue: RegExp;
+    readonly numeralsRange: RegExp;
+    readonly ellipsisRange: RegExp;
+    readonly multipleEllipsis: RegExp;
+    readonly walletSymbolBeforeValue: RegExp;
+    readonly walletSymbolAfterValue: RegExp;
+    readonly walletISOBeforeValue: RegExp;
+    readonly walletISOAfterValue: RegExp;
+    readonly expressiveAposiopesis: RegExp;
+    readonly backwardsExpressiveAposiopesis: RegExp;
+    readonly temperature: RegExp;
+};
+export default EXPRESSIONS;
+//# sourceMappingURL=common.d.ts.map

package/dist/typography/expressions/en.d.ts

@@ -0,0 +1,25 @@
+declare const EXPRESSIONS: {
+    readonly numberNumeral: RegExp;
+    readonly invalidPunctuationSpacing: RegExp;
+    readonly siUnitMul: RegExp;
+    readonly siUnitDiv: RegExp;
+    readonly siUnitBase: RegExp;
+    readonly siUnitPowAfterNum: RegExp;
+    readonly siUnitPow: RegExp;
+    readonly plusMinus: RegExp;
+    readonly minusPlus: RegExp;
+    readonly sectionNumeral: RegExp;
+    readonly percentValue: RegExp;
+    readonly numeralsRange: RegExp;
+    readonly ellipsisRange: RegExp;
+    readonly multipleEllipsis: RegExp;
+    readonly walletSymbolBeforeValue: RegExp;
+    readonly walletSymbolAfterValue: RegExp;
+    readonly walletISOBeforeValue: RegExp;
+    readonly walletISOAfterValue: RegExp;
+    readonly expressiveAposiopesis: RegExp;
+    readonly backwardsExpressiveAposiopesis: RegExp;
+    readonly temperature: RegExp;
+};
+export default EXPRESSIONS;
+//# sourceMappingURL=en.d.ts.map

package/dist/typography/expressions/ru.d.ts

@@ -0,0 +1,29 @@
+declare const EXPRESSIONS: {
+    readonly numeroNumeral: RegExp;
+    readonly invalidPunctuationSpacing: RegExp;
+    readonly dialogEmDash: RegExp;
+    readonly attributionEmDash: RegExp;
+    readonly subjectPredicateEmDash: RegExp;
+    readonly siUnitMul: RegExp;
+    readonly siUnitDiv: RegExp;
+    readonly siUnitBase: RegExp;
+    readonly siUnitPowAfterNum: RegExp;
+    readonly siUnitPow: RegExp;
+    readonly date: RegExp;
+    readonly plusMinus: RegExp;
+    readonly minusPlus: RegExp;
+    readonly sectionNumeral: RegExp;
+    readonly percentValue: RegExp;
+    readonly numeralsRange: RegExp;
+    readonly ellipsisRange: RegExp;
+    readonly multipleEllipsis: RegExp;
+    readonly walletSymbolBeforeValue: RegExp;
+    readonly walletSymbolAfterValue: RegExp;
+    readonly walletISOBeforeValue: RegExp;
+    readonly walletISOAfterValue: RegExp;
+    readonly expressiveAposiopesis: RegExp;
+    readonly backwardsExpressiveAposiopesis: RegExp;
+    readonly temperature: RegExp;
+};
+export default EXPRESSIONS;
+//# sourceMappingURL=ru.d.ts.map

package/dist/typography/markup/common.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared markup rules applied across all locales.
+ *
+ * Handles:
+ * - whitespace normalization
+ * - dash normalization (hyphens, en/em dashes)
+ * - ellipsis conversion
+ * - math symbol normalization
+ * - number spacing rules
+ * - apostrophe normalization
+ *
+ * This layer forms the base typography pipeline
+ * before locale-specific transformations.
+ */
+declare const _default: import("../..").Rule[];
+export default _default;
+//# sourceMappingURL=common.d.ts.map

package/dist/typography/markup/en.d.ts

@@ -0,0 +1,3 @@
+declare const _default: never[];
+export default _default;
+//# sourceMappingURL=en.d.ts.map

package/dist/typography/markup/index.d.ts

@@ -0,0 +1,4 @@
+export { default as common } from './common';
+export { default as en } from './en';
+export { default as ru } from './ru';
+//# sourceMappingURL=index.d.ts.map

package/dist/typography/markup/ru.d.ts

@@ -0,0 +1,3 @@
+declare const _default: never[];
+export default _default;
+//# sourceMappingURL=ru.d.ts.map

package/dist/typography/sets/ang.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../..").Rule[];
+export default _default;
+//# sourceMappingURL=ang.d.ts.map

package/dist/typography/sets/common.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared typography rules applied across all locales.
+ *
+ * Handles:
+ * - whitespace normalization
+ * - dash normalization (hyphens, en/em dashes)
+ * - ellipsis conversion
+ * - math symbol normalization
+ * - number spacing rules
+ * - apostrophe normalization
+ *
+ * This layer forms the base typography pipeline
+ * before locale-specific transformations.
+ */
+declare const _default: import("../..").Rule[];
+export default _default;
+//# sourceMappingURL=common.d.ts.map

package/dist/typography/sets/en.d.ts

@@ -0,0 +1,14 @@
+/**
+ * English typography ruleset.
+ *
+ * Includes:
+ * - smart quote replacement (US style)
+ * - ligature substitution (fi, fl, ffi, ffl)
+ * - currency formatting normalization
+ * - spacing cleanup for punctuation
+ *
+ * Designed for Latin-script typography processing.
+ */
+declare const _default: import("../..").Rule[];
+export default _default;
+//# sourceMappingURL=en.d.ts.map

package/dist/typography/sets/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ang } from './ang';
+export { default as common } from './common';
+export { default as en } from './en';
+export { default as ru } from './ru';
+//# sourceMappingURL=index.d.ts.map

package/dist/typography/sets/ru.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Russian typography ruleset.
+ *
+ * Extends common rules with:
+ * - Russian-style smart quotes
+ * - spacing normalization for punctuation
+ * - em-dash formatting rules
+ * - currency formatting (RUB and others)
+ * - abbreviation spacing rules
+ * - grammatical particle spacing rules
+ *
+ * Designed for Cyrillic-script normalization.
+ */
+declare const _default: import("../..").Rule[];
+export default _default;
+//# sourceMappingURL=ru.d.ts.map

package/dist/typography/store.d.ts

@@ -0,0 +1,63 @@
+import type { Rule } from '@/types';
+/**
+ * Global typography rule registry.
+ *
+ * Stores rule pipelines grouped by locale key.
+ *
+ * Structure:
+ * — "common": rules applied to all locales
+ * — "[locale]": locale-specific rule overrides
+ *
+ * Each entry contains a list of transformation rules
+ * executed during typography processing.
+ *
+ * Direct assignment (e.g. typographyRules['en'] = [...]) automatically
+ * invalidates the weighted rules cache for the affected locale.
+ */
+export declare const typographyRules: Record<string, Rule[] | undefined>;
+/**
+ * Returns a merged and weight-sorted rule pipeline.
+ *
+ * Combines:
+ * — common rules
+ * — locale-specific rules
+ *
+ * Result is cached per locale and invalidated automatically
+ * when rules are registered or reset for that locale.
+ *
+ * Sorting:
+ * — rules are ordered by `weight` (ascending)
+ * — rules without weight default to 0
+ * — stable order is preserved for equal weights
+ *
+ * @param locale — Target locale key
+ * @returns Flattened and sorted rule pipeline
+ */
+export declare function getWeightedRules(locale: string): Rule[];
+/**
+ * Resets all typography rules in the registry.
+ *
+ * Clears all locale-specific pipelines including "common".
+ * After reset, all rule groups become empty arrays.
+ *
+ * Useful for:
+ * — testing
+ * — reinitialization
+ * — dynamic rule reloading
+ */
+export declare function resetTypographyRules(): void;
+/**
+ * Checks if a locale-specific rule pipeline exists.
+ *
+ * @param locale — Target locale key
+ * @returns `true` if pipeline exists and non-empty, `false` otherwise
+ */
+export declare function rulesHas(locale: string): boolean;
+/**
+ * Returns the number of rules in a locale-specific rule pipeline.
+ *
+ * @param locale — Target locale key
+ * @returns Number of rules in the pipeline
+ */
+export declare function rulesCount(locale: string): number;
+//# sourceMappingURL=store.d.ts.map