@nkardaz/typography-rules 1.0.0

package/dist/helpers/index.mjs

@@ -0,0 +1,245 @@
+// src/typography/aliases.ts
+function createAlias(map) {
+  const normalized = Object.fromEntries(
+    Object.entries(map).map(([key, values]) => [
+      key.toLowerCase(),
+      values.map((v) => v.toLowerCase())
+    ])
+  );
+  const methods = {
+    /**
+     * 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) {
+      const a = alias.toLowerCase();
+      if (a in normalized) return true;
+      return Object.values(normalized).some((vals) => vals.includes(a));
+    },
+    /**
+     * 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) {
+      const a = alias.toLowerCase();
+      if (a in normalized) return a;
+      return Object.keys(normalized).find((k) => {
+        const values = normalized[k];
+        return Array.isArray(values) && values.includes(a);
+      });
+    },
+    /**
+     * 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, ...aliases) {
+      for (const alias of aliases) {
+        const a = alias.toLowerCase();
+        const r = root.toLowerCase();
+        if (a in normalized) {
+          normalized[a]?.push(r);
+        } else {
+          normalized[a] = [r];
+        }
+      }
+    },
+    /**
+     * 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) {
+      return alias.map((a) => a.toLowerCase());
+    }
+  };
+  return new Proxy(methods, {
+    get(target, prop) {
+      if (prop in target) return target[prop];
+      return normalized[prop];
+    },
+    has(_target, prop) {
+      return prop in normalized;
+    },
+    ownKeys() {
+      return [...Object.keys(normalized), ...Object.keys(methods)];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop in normalized || prop in methods) {
+        return { enumerable: true, configurable: true };
+      }
+      return void 0;
+    }
+  });
+}
+var ALIAS = createAlias({
+  ru: ["ru-RU", "Russian", "\u0420\u0443\u0441\u0441\u043A\u0438\u0439"],
+  en: ["en-US", "English"],
+  ang: ["\xC6nglis\u010B", "\xC6nglisc", "Old English"]
+});
+
+// src/helpers/index.ts
+var NODE_MARKER = "\uE000\uEDFD\uF43E";
+var PROTECTION_MARKER = "\uE001\uEDF1\uF111";
+var NODE_MARKER_REGEX = new RegExp(NODE_MARKER, "g");
+var PROTECTION_MARKER_REGEX = new RegExp(PROTECTION_MARKER, "g");
+var patternProto = {
+  get values() {
+    return Object.keys(this).map((key) => {
+      const desc = Object.getOwnPropertyDescriptor(this, key);
+      return desc?.get ? this[key] : void 0;
+    }).filter((v) => v !== void 0);
+  },
+  combined(locale) {
+    const key = locale ? ALIAS.resolve(locale) ?? locale : void 0;
+    const baseSources = this.values.map((p) => `(${p.source})`);
+    const localeSources = [];
+    const locales = localeRegistry.get(this);
+    if (key && locales) {
+      const sub = locales.get(key);
+      if (sub) {
+        for (const rx of Object.values(sub)) {
+          localeSources.push(`(${rx.source})`);
+        }
+      }
+    }
+    const source = [...baseSources, ...localeSources].join("|");
+    return new RegExp(source, "g");
+  },
+  insert(patterns) {
+    const locales = localeRegistry.get(this) ?? /* @__PURE__ */ new Map();
+    for (const key of Object.keys(patterns)) {
+      const value = patterns[key];
+      if (value instanceof RegExp) {
+        const src = value.source;
+        const flags = value.flags;
+        Object.defineProperty(this, key, {
+          get() {
+            return new RegExp(src, flags);
+          },
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        locales.set(key, value);
+        localeRegistry.set(this, locales);
+      }
+    }
+  },
+  *[Symbol.iterator]() {
+    for (const key of Object.keys(this)) {
+      const desc = Object.getOwnPropertyDescriptor(this, key);
+      if (desc?.get) yield this[key];
+    }
+  }
+};
+function createPatterns(patterns) {
+  const result = Object.create(patternProto);
+  const locales = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(patterns)) {
+    const value = patterns[key];
+    if (value instanceof RegExp) {
+      const src = value.source;
+      const flags = value.flags;
+      Object.defineProperty(result, key, {
+        get() {
+          return new RegExp(src, flags);
+        },
+        enumerable: true,
+        configurable: true
+      });
+    } else {
+      locales.set(key, value);
+    }
+  }
+  localeRegistry.set(result, locales);
+  return result;
+}
+var localeRegistry = /* @__PURE__ */ new WeakMap();
+var PROTECTED_PATTERNS = createPatterns({
+  email: /[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9_-]+/g,
+  url: /https?:\/\/[^\s]+/g,
+  unixPath: /\/[a-zA-Z0-9._\-/]+\.[a-zA-Z0-9]+/g,
+  windowsPath: /[A-Za-z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*/g,
+  xmlTag: /<\/?[a-zA-Z][^>]*>/g,
+  inlineCode: /`[^`\n]+`/g,
+  blockCode: /```[\s\S]*?```/g,
+  uuid: /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi,
+  hash: /\b(?=[0-9a-f]*[a-f])[0-9a-f]{7,40}\b/gi,
+  ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+  ipv6: /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b/g,
+  mac: /\b(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\b/g,
+  version: /\bv?\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?\b/g,
+  selector: /[.#][A-Za-z_][\w-]*/g,
+  cliOption: /--?[a-zA-Z][\w-]*/g,
+  hashNumber: /(?<!\w)#[0-9]+\b/g,
+  isbn: /\b(?:97[89][- ]?)?(?:\d[- ]?){9}[\dX]\b/g,
+  issn: /\b\d{4}-\d{3}[\dX]\b/g,
+  doi: /\b10\.\d{4,9}\/[-._;()/:A-Za-z0-9]+\b/g,
+  orcid: /\b\d{4}-\d{4}-\d{4}-\d{3}[\dX]\b/g,
+  protect: /\[##\((.+)\)##\]/g,
+  ["ru"]: {}
+});
+function protect(text, locale) {
+  const key = locale ? ALIAS.resolve(locale) ?? locale : void 0;
+  const captured = [];
+  const withNodeMarkers = text.replace(NODE_MARKER_REGEX, (match) => {
+    captured.push(match);
+    return PROTECTION_MARKER;
+  });
+  const withPatterns = withNodeMarkers.replace(PROTECTED_PATTERNS.combined(key), (match) => {
+    captured.push(match);
+    return PROTECTION_MARKER;
+  });
+  return [withPatterns, captured];
+}
+function unprotect(text, captured) {
+  const queue = [...captured];
+  return text.replace(PROTECTION_MARKER_REGEX, () => queue.shift() ?? "").replace(PROTECTED_PATTERNS.protect, "$1");
+}
+function joinNodes(nodes) {
+  return nodes.map((n) => n.value).join(NODE_MARKER);
+}
+function splitNodes(text, nodes) {
+  const segments = text.split(NODE_MARKER);
+  nodes.forEach((n, i) => {
+    n.value = segments[i] ?? n.value;
+  });
+}
+export {
+  NODE_MARKER,
+  NODE_MARKER_REGEX,
+  PROTECTED_PATTERNS,
+  PROTECTION_MARKER,
+  PROTECTION_MARKER_REGEX,
+  createPatterns,
+  joinNodes,
+  protect,
+  splitNodes,
+  unprotect
+};
+//# sourceMappingURL=index.mjs.map

package/dist/helpers/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Raw map of named RegExp patterns.
+ *
+ * Used as input to `createPatterns` to build a pattern registry
+ * with prototype utilities and safe per-access instantiation.
+ */
+export type PatternData = Record<string, RegExp | LocalePatterns>;
+export type LocalePatterns = Record<string, RegExp>;
+/**
+ * A pattern registry with prototype utilities attached.
+ *
+ * Each key from the source `PatternData` becomes a readonly accessor
+ * that returns a fresh `RegExp` instance on every access, preventing
+ * `lastIndex` pollution from the `g` flag across multiple calls.
+ *
+ * @template T — Shape of the source pattern map
+ */
+export type PatternSet<T extends PatternData> = {
+    [K in keyof T as T[K] extends RegExp ? K : never]: RegExp;
+} & Record<string, RegExp | undefined> & PatternProto;
+/**
+ * Prototype object attached to all pattern registries created by `createPatterns`.
+ *
+ * Provides shared `values` getter and `Symbol.iterator` without polluting
+ * the enumerable key space of the registry itself.
+ *
+ * Mirrors the role of `proto` in `createCharacters` from the glyphs module.
+ */
+export interface PatternProto {
+    /**
+     * Returns all RegExp patterns from the registry.
+     *
+     * Each access returns fresh `RegExp` instances with `lastIndex = 0`,
+     * preventing stateful issues with the `g` flag.
+     *
+     * Used when applying batch protection in preprocessing pipelines.
+     */
+    readonly values: RegExp[];
+    /**
+     * Returns a single RegExp that combines all patterns via alternation.
+     *
+     * Built from `.source` of each pattern — safe to cache, as `lastIndex`
+     * is not involved at construction time.
+     *
+     * Prefer this over iterating `.values` with sequential `.replace()` calls —
+     * a single combined pass prevents one pattern from corrupting input for another.
+     *
+     * @param flags - RegExp flags for the combined pattern (default: `'g'`)
+     */
+    combined(flags?: string, locale?: string): RegExp;
+    /**
+     * Populates the registry with new patterns.
+     *
+     * Each pattern is stored as a getter that returns a new `RegExp` instance
+     * on every access, ensuring `lastIndex` is always reset to `0` regardless
+     * of how the pattern was previously used.
+     *
+     * @param patterns - Raw map of named RegExp patterns
+     */
+    insert(patterns: PatternData): void;
+    /**
+     * Iterator over all RegExp patterns in the registry.
+     *
+     * Each access returns fresh `RegExp` instances with `lastIndex = 0`,
+     * preventing stateful issues with the `g` flag.
+     *
+     * Enables usage in for..of loops, spreading, and pipeline-based processing.
+     */
+    [Symbol.iterator](): Iterator<RegExp>;
+}
+//# sourceMappingURL=types.d.ts.map