@uzum-tech/ui 2.3.4 → 2.3.6

package/es/_utils/markdown/constants.d.ts

@@ -0,0 +1,27 @@
+import type { MarkdownFeature } from '@uzum-tech/ui';
+export declare const HTML_COMMENT_REGEX: RegExp;
+export declare const HTML_CDATA_REGEX: RegExp;
+export declare const HTML_RAW_BLOCK_REGEX: RegExp;
+export declare const HTML_DECLARATION_REGEX: RegExp;
+export declare const HTML_TAG_REGEX: RegExp;
+export declare const ANY_HTML_TAG_REGEX: RegExp;
+export declare const WHITESPACE_REGEX: RegExp;
+export declare const MAX_HEADING_LEVEL = 3;
+export declare const MAX_DIVIDER_INDENT = 4;
+export declare const MIN_DIVIDER_MARKERS = 3;
+export declare const EMPTY_BLOCK_TOKEN_COUNT = 3;
+export declare const CHAR_CODES: {
+    TILDE: number;
+    EQUALS: number;
+    SPACE: number;
+    TAB: number;
+};
+export declare const HTML_ENTITY_REPLACEMENTS: Array<[RegExp, string]>;
+export declare const ALL_MARKDOWN_FEATURES: MarkdownFeature[];
+export declare const INVISIBLE_INLINE_TOKEN_TYPES: string[];
+export declare const MARKDOWN_SYMBOL: {
+    TILDE: string;
+    STRIKETHROUGH_TAG: string;
+    PARAGRAPH_TAG: string;
+    NEWLINE: string;
+};

package/es/_utils/markdown/constants.mjs

@@ -0,0 +1,26 @@
+export const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
+export const HTML_CDATA_REGEX = /<!\[CDATA\[[\s\S]*?\]\]>/g;
+export const HTML_RAW_BLOCK_REGEX = /<(script|style|iframe|object|embed|template|svg|math|noscript)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+export const HTML_DECLARATION_REGEX = /<[!?][^>]*>/g;
+export const HTML_TAG_REGEX = /<\/?[a-z][\w:-]*(?:\s[^<>]*)?\/?>/gi;
+export const ANY_HTML_TAG_REGEX = /<[^>]*>/g;
+export const WHITESPACE_REGEX = /\s+/g;
+export const MAX_HEADING_LEVEL = 3;
+export const MAX_DIVIDER_INDENT = 4;
+export const MIN_DIVIDER_MARKERS = 3;
+export const EMPTY_BLOCK_TOKEN_COUNT = 3;
+export const CHAR_CODES = {
+  TILDE: 0x7E,
+  EQUALS: 0x3D,
+  SPACE: 0x20,
+  TAB: 0x09
+};
+export const HTML_ENTITY_REPLACEMENTS = [[/&lt;/g, '<'], [/&gt;/g, '>'], [/&quot;/g, '"'], [/&amp;/g, '&']];
+export const ALL_MARKDOWN_FEATURES = ['bold', 'italic', 'strikethrough', 'heading', 'orderedList', 'bulletList', 'blockquote', 'divider'];
+export const INVISIBLE_INLINE_TOKEN_TYPES = ['softbreak', 'hardbreak', 'image', 'link_open', 'link_close', 'strong_open', 'strong_close', 'em_open', 'em_close', 's_open', 's_close'];
+export const MARKDOWN_SYMBOL = {
+  TILDE: '~',
+  STRIKETHROUGH_TAG: 's',
+  PARAGRAPH_TAG: 'p',
+  NEWLINE: '\n'
+};

package/es/_utils/markdown/create-markdown-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownIt as MarkdownItInstance } from 'markdown-it';
+import type { NormalizedMarkdownOptions } from './interface';
+export declare function createMarkdownRenderer(resolved: NormalizedMarkdownOptions): MarkdownItInstance;

package/es/_utils/markdown/create-markdown-renderer.mjs

@@ -0,0 +1,65 @@
+import MarkdownIt from 'markdown-it';
+import createClampHeadingRule from "./rulers/clamp-heading.mjs";
+import equalsDivider from "./rulers/equals-divider.mjs";
+import pruneEmptyBlocksCoreRule from "./rulers/prune-empty-blocks.mjs";
+import strikethroughInlineRule from "./rulers/strikethrough.mjs";
+import stripHtmlCoreRule from "./rulers/strip-html.mjs";
+function applyFeatureRendererOverrides(md, enabled) {
+  const unwrap = () => '';
+  if (!enabled.has('bold')) {
+    md.renderer.rules.strong_open = unwrap;
+    md.renderer.rules.strong_close = unwrap;
+  }
+  if (!enabled.has('italic')) {
+    md.renderer.rules.em_open = unwrap;
+    md.renderer.rules.em_close = unwrap;
+  }
+  if (!enabled.has('strikethrough')) {
+    md.renderer.rules.s_open = unwrap;
+    md.renderer.rules.s_close = unwrap;
+  }
+  if (!enabled.has('blockquote')) {
+    md.renderer.rules.blockquote_open = unwrap;
+    md.renderer.rules.blockquote_close = unwrap;
+  }
+  if (!enabled.has('orderedList')) {
+    md.renderer.rules.ordered_list_open = unwrap;
+    md.renderer.rules.ordered_list_close = unwrap;
+  }
+  if (!enabled.has('bulletList')) {
+    md.renderer.rules.bullet_list_open = unwrap;
+    md.renderer.rules.bullet_list_close = unwrap;
+  }
+  if (!enabled.has('divider')) {
+    md.renderer.rules.hr = unwrap;
+  }
+}
+export function createMarkdownRenderer(resolved) {
+  const enabled = new Set(resolved.features);
+  const markdown = new MarkdownIt('zero', {
+    html: false,
+    linkify: false,
+    breaks: resolved.breaks,
+    typographer: false
+  });
+  markdown.enable(['emphasis', 'strikethrough', 'heading', 'list', 'blockquote', 'hr', 'newline', 'escape', 'link', 'image', 'autolink']);
+  markdown.core.ruler.before('normalize', 'u_strip_html', stripHtmlCoreRule);
+  markdown.block.ruler.before('paragraph', 'u_equals_divider', equalsDivider, {
+    alt: ['paragraph', 'reference', 'blockquote', 'list']
+  });
+  markdown.inline.ruler.before('strikethrough', 'u_strikethrough', strikethroughInlineRule);
+  if (!enabled.has('heading')) {
+    markdown.disable('heading');
+  } else {
+    markdown.core.ruler.after('block', 'u_clamp_heading', createClampHeadingRule(resolved.maxHeadingLevel));
+  }
+  markdown.core.ruler.push('u_prune_empty_blocks', pruneEmptyBlocksCoreRule);
+  markdown.validateLink = () => true;
+  markdown.renderer.rules.link_open = () => '';
+  markdown.renderer.rules.link_close = () => '';
+  markdown.renderer.rules.image = () => '';
+  markdown.renderer.rules.html_block = () => '';
+  markdown.renderer.rules.html_inline = () => '';
+  applyFeatureRendererOverrides(markdown, enabled);
+  return markdown;
+}

package/es/_utils/markdown/index.d.ts

@@ -0,0 +1,2 @@
+export type { MarkdownFeature, MarkdownOptions } from './interface';
+export { renderMarkdown, sanitizeMarkdown } from './render-markdown';

package/es/_utils/markdown/index.mjs

@@ -0,0 +1 @@
+export { renderMarkdown, sanitizeMarkdown } from "./render-markdown.mjs";

package/es/_utils/markdown/interface.d.ts

@@ -0,0 +1,14 @@
+export declare enum TOKEN_TYPE {
+    HEADING_OPEN = "heading_open",
+    HEADING_CLOSE = "heading_close",
+    PARAGRAPH_OPEN = "paragraph_open",
+    PARAGRAPH_CLOSE = "paragraph_close"
+}
+export interface MarkdownOptions {
+    features?: MarkdownFeature[];
+    maxHeadingLevel?: number;
+    breaks?: boolean;
+}
+export interface NormalizedMarkdownOptions extends Required<MarkdownOptions> {
+}
+export type MarkdownFeature = 'bold' | 'italic' | 'strikethrough' | 'heading' | 'orderedList' | 'bulletList' | 'blockquote' | 'divider';

package/es/_utils/markdown/interface.mjs

@@ -0,0 +1,7 @@
+export var TOKEN_TYPE;
+(function (TOKEN_TYPE) {
+  TOKEN_TYPE["HEADING_OPEN"] = "heading_open";
+  TOKEN_TYPE["HEADING_CLOSE"] = "heading_close";
+  TOKEN_TYPE["PARAGRAPH_OPEN"] = "paragraph_open";
+  TOKEN_TYPE["PARAGRAPH_CLOSE"] = "paragraph_close";
+})(TOKEN_TYPE || (TOKEN_TYPE = {}));

package/es/_utils/markdown/render-markdown.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownOptions } from './interface';
+export declare function renderMarkdown(content: string, options?: MarkdownOptions): string;
+export declare function sanitizeMarkdown(content: string, options?: MarkdownOptions): string;

package/es/_utils/markdown/render-markdown.mjs

@@ -0,0 +1,31 @@
+import { ALL_MARKDOWN_FEATURES, ANY_HTML_TAG_REGEX, HTML_ENTITY_REPLACEMENTS, MAX_HEADING_LEVEL, WHITESPACE_REGEX } from "./constants.mjs";
+import { createMarkdownRenderer } from "./create-markdown-renderer.mjs";
+const rendererCache = new Map();
+function normalizeOptions(options) {
+  var _a, _b, _c;
+  return {
+    features: [...((_a = options === null || options === void 0 ? void 0 : options.features) !== null && _a !== void 0 ? _a : ALL_MARKDOWN_FEATURES)],
+    maxHeadingLevel: Math.min(MAX_HEADING_LEVEL, Math.max(1, (_b = options === null || options === void 0 ? void 0 : options.maxHeadingLevel) !== null && _b !== void 0 ? _b : MAX_HEADING_LEVEL)),
+    breaks: (_c = options === null || options === void 0 ? void 0 : options.breaks) !== null && _c !== void 0 ? _c : true
+  };
+}
+function getMarkdownRenderer(options) {
+  const normalizedOptions = normalizeOptions(options);
+  const instance = rendererCache.get(normalizedOptions);
+  if (!instance) {
+    const renderer = createMarkdownRenderer(normalizedOptions);
+    rendererCache.set(normalizedOptions, renderer);
+    return renderer;
+  }
+  return instance;
+}
+export function renderMarkdown(content, options) {
+  if (!content) return '';
+  return getMarkdownRenderer(options).render(content).trim();
+}
+export function sanitizeMarkdown(content, options) {
+  if (!content) return '';
+  let text = renderMarkdown(content, options).replace(ANY_HTML_TAG_REGEX, ' ');
+  for (const [pattern, replacement] of HTML_ENTITY_REPLACEMENTS) text = text.replace(pattern, replacement);
+  return text.replace(WHITESPACE_REGEX, ' ').trim();
+}

package/es/_utils/markdown/rulers/clamp-heading.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function createClampHeadingRule(maxLevel: number): (state: StateCore) => void;

package/es/_utils/markdown/rulers/clamp-heading.mjs

@@ -0,0 +1,25 @@
+import { TOKEN_TYPE } from "../interface.mjs";
+function toParagraph(token, type) {
+  token.type = type;
+  token.tag = 'p';
+  token.markup = '';
+}
+export default function createClampHeadingRule(maxLevel) {
+  return state => {
+    for (let index = 0; index < state.tokens.length; index++) {
+      const openToken = state.tokens[index];
+      if (openToken.type !== TOKEN_TYPE.HEADING_OPEN) continue;
+      const level = Number(openToken.tag.slice(1));
+      if (!Number.isFinite(level) || level <= maxLevel) continue;
+      const inlineToken = state.tokens[index + 1];
+      const closeToken = state.tokens[index + 2];
+      toParagraph(openToken, TOKEN_TYPE.PARAGRAPH_OPEN);
+      if ((closeToken === null || closeToken === void 0 ? void 0 : closeToken.type) === TOKEN_TYPE.HEADING_CLOSE) {
+        toParagraph(closeToken, TOKEN_TYPE.PARAGRAPH_CLOSE);
+      }
+      if ((inlineToken === null || inlineToken === void 0 ? void 0 : inlineToken.type) === 'inline') {
+        inlineToken.content = `${'#'.repeat(level)} ${inlineToken.content}`;
+      }
+    }
+  };
+}

package/es/_utils/markdown/rulers/equals-divider.d.ts

@@ -0,0 +1,2 @@
+import type { StateBlock } from 'markdown-it';
+export default function equalsDivider(state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean;

package/es/_utils/markdown/rulers/equals-divider.mjs

@@ -0,0 +1,19 @@
+import { CHAR_CODES, MAX_DIVIDER_INDENT, MIN_DIVIDER_MARKERS } from "../constants.mjs";
+export default function equalsDivider(state, startLine, endLine, silent) {
+  if (state.sCount[startLine] - state.blkIndent >= MAX_DIVIDER_INDENT) return false;
+  let position = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  let count = 0;
+  while (position < max) {
+    const charCode = state.src.charCodeAt(position);
+    if (charCode === CHAR_CODES.EQUALS) count++;else if (charCode !== CHAR_CODES.SPACE && charCode !== CHAR_CODES.TAB) return false;
+    position++;
+  }
+  if (count < MIN_DIVIDER_MARKERS) return false;
+  if (silent) return true;
+  state.line = startLine + 1;
+  const token = state.push('hr', 'hr', 0);
+  token.map = [startLine, state.line];
+  token.markup = '='.repeat(count);
+  return true;
+}

package/es/_utils/markdown/rulers/prune-empty-blocks.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function pruneEmptyBlocksCoreRule(state: StateCore): void;

package/es/_utils/markdown/rulers/prune-empty-blocks.mjs

@@ -0,0 +1,31 @@
+import { EMPTY_BLOCK_TOKEN_COUNT, INVISIBLE_INLINE_TOKEN_TYPES } from "../constants.mjs";
+import { TOKEN_TYPE } from "../interface.mjs";
+function inlineHasVisibleContent(children) {
+  if (!children || children.length === 0) return false;
+  for (const child of children) {
+    if (child.type === 'text') {
+      if (child.content.trim().length > 0) return true;
+      continue;
+    }
+    if (!INVISIBLE_INLINE_TOKEN_TYPES.includes(child.type)) return true;
+  }
+  return false;
+}
+export default function pruneEmptyBlocksCoreRule(state) {
+  const {
+    tokens
+  } = state;
+  for (let index = 0; index < tokens.length; index++) {
+    const openToken = tokens[index];
+    const isPrunableBlock = openToken.type === TOKEN_TYPE.PARAGRAPH_OPEN || openToken.type === TOKEN_TYPE.HEADING_OPEN;
+    if (!isPrunableBlock) continue;
+    const inlineToken = tokens[index + 1];
+    const closeToken = tokens[index + 2];
+    const closeType = openToken.type === TOKEN_TYPE.PARAGRAPH_OPEN ? TOKEN_TYPE.PARAGRAPH_CLOSE : TOKEN_TYPE.HEADING_CLOSE;
+    if ((inlineToken === null || inlineToken === void 0 ? void 0 : inlineToken.type) !== 'inline' || (closeToken === null || closeToken === void 0 ? void 0 : closeToken.type) !== closeType) continue;
+    if (!inlineHasVisibleContent(inlineToken.children)) {
+      tokens.splice(index, EMPTY_BLOCK_TOKEN_COUNT);
+      index -= 1;
+    }
+  }
+}

package/es/_utils/markdown/rulers/strikethrough.d.ts

@@ -0,0 +1,3 @@
+import type { StateInline } from 'markdown-it';
+declare function strikethroughInlineRule(state: StateInline, silent: boolean): boolean;
+export default strikethroughInlineRule;

package/es/_utils/markdown/rulers/strikethrough.mjs

@@ -0,0 +1,38 @@
+import { CHAR_CODES, MARKDOWN_SYMBOL } from "../constants.mjs";
+function strikethroughInlineRule(state, silent) {
+  const max = state.posMax;
+  const start = state.pos;
+  if (state.src.charCodeAt(start) !== CHAR_CODES.TILDE) return false;
+  if (silent) return false;
+  if (start + 2 >= max) return false;
+  state.pos = start + 1;
+  let found = false;
+  while (state.pos < max) {
+    if (state.src.charCodeAt(state.pos) === CHAR_CODES.TILDE) {
+      found = true;
+      break;
+    }
+    state.md.inline.skipToken(state);
+  }
+  if (!found || start + 1 === state.pos) {
+    state.pos = start;
+    return false;
+  }
+  const content = state.src.slice(start + 1, state.pos);
+  if (content.includes(MARKDOWN_SYMBOL.NEWLINE)) {
+    state.pos = start;
+    return false;
+  }
+  state.posMax = state.pos;
+  state.pos = start + 1;
+  let token = state.push('s_open', MARKDOWN_SYMBOL.STRIKETHROUGH_TAG, 1);
+  token.markup = MARKDOWN_SYMBOL.TILDE;
+  token = state.push('text', '', 0);
+  token.content = content.replace(/\\(.)/g, '$1');
+  token = state.push('s_close', MARKDOWN_SYMBOL.STRIKETHROUGH_TAG, -1);
+  token.markup = MARKDOWN_SYMBOL.TILDE;
+  state.pos = state.posMax + 1;
+  state.posMax = max;
+  return true;
+}
+export default strikethroughInlineRule;

package/es/_utils/markdown/rulers/strip-html.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function stripHtmlCoreRule(state: StateCore): void;

package/es/_utils/markdown/rulers/strip-html.mjs

@@ -0,0 +1,7 @@
+import { HTML_CDATA_REGEX, HTML_COMMENT_REGEX, HTML_DECLARATION_REGEX, HTML_RAW_BLOCK_REGEX, HTML_TAG_REGEX } from "../constants.mjs";
+function stripHtml(source) {
+  return source.replace(HTML_COMMENT_REGEX, '').replace(HTML_CDATA_REGEX, '').replace(HTML_RAW_BLOCK_REGEX, '').replace(HTML_DECLARATION_REGEX, '').replace(HTML_TAG_REGEX, '');
+}
+export default function stripHtmlCoreRule(state) {
+  state.src = stripHtml(state.src);
+}