@appaflytech/zeyrek-ai-mcp 0.0.21 → 0.0.23

package/dist/knowledge/styleResolveNative.js

@@ -0,0 +1,410 @@
+import { rawProp } from './styleResolve.js';
+import { mergeTypeScale, resolveTheme } from './themeResolve.js';
+/* ---- css-value.ts ---- */
+const warn = (context, message) => {
+    context?.warnings?.push(message);
+    return null;
+};
+export function parseLength(value, context) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    const text = String(value).trim();
+    if (!text)
+        return null;
+    const numeric = Number(text);
+    if (Number.isFinite(numeric))
+        return numeric;
+    if (text.endsWith('%')) {
+        const percent = Number(text.slice(0, -1));
+        return Number.isFinite(percent) ? `${percent}%` : null;
+    }
+    const unit = /^(-?[\d.]+)(px|em|rem)$/.exec(text);
+    if (unit) {
+        const amount = Number(unit[1]);
+        if (!Number.isFinite(amount))
+            return null;
+        if (unit[2] === 'px')
+            return amount;
+        const base = unit[2] === 'em' ? context?.base ?? context?.root : context?.root;
+        if (base === undefined)
+            return warn(context, `${text}: em/rem tabanı yok, değer atlandı`);
+        return Math.round(amount * base * 1000) / 1000;
+    }
+    return warn(context, `${text}: React Native'de karşılığı olmayan uzunluk`);
+}
+export function parsePanelLength(value, context) {
+    if (typeof value === 'number' && value === 0)
+        return null;
+    return parseLength(value, context);
+}
+export function parseFontFamily(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const first = String(value).split(',')[0].trim().replace(/^["']|["']$/g, '');
+    return first || null;
+}
+export function parseLineHeight(value, fontSize, context) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const text = String(value).trim();
+    const numeric = Number(text);
+    const base = fontSize ?? context?.base ?? context?.root;
+    if (Number.isFinite(numeric)) {
+        if (numeric <= 0)
+            return null;
+        const ratio = numeric >= 4 ? numeric / 100 : numeric;
+        if (base === undefined)
+            return warn(context, `lineHeight ${text}: punto bilinmiyor, atlandı`);
+        return Math.round(ratio * base * 1000) / 1000;
+    }
+    if (text.endsWith('%')) {
+        const percent = Number(text.slice(0, -1));
+        if (!Number.isFinite(percent) || base === undefined)
+            return warn(context, `lineHeight ${text}: punto bilinmiyor, atlandı`);
+        return Math.round((percent / 100) * base * 1000) / 1000;
+    }
+    const length = parseLength(text, context);
+    return typeof length === 'number' ? length : null;
+}
+export function parseOpacity(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const amount = Number(value);
+    if (!Number.isFinite(amount) || amount < 0 || amount >= 100)
+        return null;
+    return Math.round((amount / 100) * 1000) / 1000;
+}
+export function parseBorderShorthand(value, context) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const text = String(value).trim();
+    if (!text || text === 'none')
+        return { width: 0, style: 'solid' };
+    const parts = text.split(/\s+(?![^(]*\))/);
+    const width = parseLength(parts[0], context);
+    if (typeof width !== 'number')
+        return warn(context, `${text}: kenarlık genişliği çözülemedi`);
+    const style = parts.find(part => /^(solid|dashed|dotted)$/.test(part)) ?? 'solid';
+    const color = parts.find(part => part !== parts[0] && !/^(solid|dashed|dotted)$/.test(part));
+    return { width, style, ...(color ? { color } : {}) };
+}
+/* ---- theme-native.ts ---- */
+const camelize = (name) => name.replace(/^--ng-/, '').replace(/-([a-z0-9])/g, (_, character) => character.toUpperCase());
+const hexToRgb = (hex) => {
+    const match = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+    if (!match)
+        return null;
+    const digits = match[1].length === 3 ? match[1].split('').map(digit => digit + digit).join('') : match[1];
+    const value = parseInt(digits, 16);
+    return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
+};
+const toHex = (channel) => Math.round(Math.max(0, Math.min(255, channel))).toString(16).padStart(2, '0');
+const NAMED_COLORS = { white: '#ffffff', black: '#000000' };
+const resolveColorMix = (value) => {
+    const match = /^color-mix\(\s*in\s+srgb\s*,\s*([^,]+?)\s+([\d.]+)%\s*,\s*([^)]+?)\s*\)$/i.exec(value.trim());
+    if (!match)
+        return value;
+    const [, rawFrom = '', percent = '0', rawTo = ''] = match;
+    const from = hexToRgb(NAMED_COLORS[rawFrom.trim()] ?? rawFrom);
+    const to = hexToRgb(NAMED_COLORS[rawTo.trim()] ?? rawTo);
+    if (!from || !to)
+        return rawFrom.trim();
+    const weight = Number(percent) / 100;
+    const mixed = from.map((channel, index) => channel * weight + to[index] * (1 - weight));
+    return `#${mixed.map(toHex).join('')}`;
+};
+const CALC_UNIT = /^(-?[\d.]+)([a-z%]*)$/;
+const evaluateCalc = (value) => {
+    let result = value;
+    while (true) {
+        const match = /calc\(([^()]*)\)/.exec(result);
+        if (!match)
+            return result;
+        const [left, operator = '', right] = match[1].trim().split(/\s+/);
+        const leftParts = CALC_UNIT.exec(left ?? '');
+        const rightAmount = Number(right);
+        if (!leftParts || !Number.isFinite(rightAmount) || !'*/'.includes(operator)) {
+            result = result.replace(match[0], match[1].trim());
+            return result;
+        }
+        const amount = operator === '*' ? Number(leftParts[1]) * rightAmount : Number(leftParts[1]) / rightAmount;
+        result = result.replace(match[0], `${Math.round(amount * 1000) / 1000}${leftParts[2]}`);
+    }
+};
+const resolveVars = (raw) => {
+    const resolved = {};
+    const expand = (value, seen) => {
+        const expanded = value.replace(/var\((--[a-z0-9-]+)(?:\s*,\s*([^)]+))?\)/g, (whole, name, fallback) => {
+            if (seen.has(name))
+                return whole;
+            const target = raw[name];
+            if (target === undefined)
+                return fallback?.trim() ?? whole;
+            return expand(target, new Set([...seen, name]));
+        });
+        return resolveColorMix(evaluateCalc(expanded));
+    };
+    for (const [name, value] of Object.entries(raw))
+        resolved[name] = expand(value, new Set([name]));
+    return resolved;
+};
+const px = (value, fallback) => {
+    if (!value)
+        return fallback;
+    const amount = Number(String(value).replace(/px$/, ''));
+    return Number.isFinite(amount) ? amount : fallback;
+};
+export function parseShadow(css) {
+    if (!css || css === 'none')
+        return {};
+    const color = /rgba?\(([^)]+)\)/.exec(css);
+    const lengths = css.replace(/rgba?\([^)]+\)/, '').trim().split(/\s+/)
+        .map(part => Number(part.replace(/px$/, '')))
+        .filter(part => Number.isFinite(part));
+    const [offsetX = 0, offsetY = 0, blur = 0] = lengths;
+    const channels = color?.[1].split(',').map(part => Number(part.trim())) ?? [];
+    const [red = 0, green = 0, blue = 0, alpha = 1] = channels;
+    return {
+        shadowColor: `#${toHex(red)}${toHex(green)}${toHex(blue)}`,
+        shadowOffset: { width: offsetX, height: offsetY },
+        shadowOpacity: alpha,
+        shadowRadius: blur,
+        elevation: Math.round(blur / 2)
+    };
+}
+/**
+ * Proje temasının mobil karşılığı. Frontend `resolveThemeNative(overrides, mode = 'light')` ile
+ * aynı: mod çağırandan gelir, temanın kendi `mode` alanı okunmaz (runtime da okumuyor).
+ */
+export function resolveThemeNative(theme, mode = 'light') {
+    const resolvedTheme = resolveTheme(theme, mode);
+    const vars = resolveVars(resolvedTheme.cssVars);
+    const tokens = resolvedTheme.tokens;
+    const colors = {};
+    for (const [name, value] of Object.entries(vars)) {
+        if (/^(#|rgb|hsl)/.test(value))
+            colors[camelize(name)] = value;
+    }
+    const fontSize = px(vars['--ng-font-size'], 14);
+    const spacingBase = px(vars['--ng-spacing'], 10);
+    const spacing = { base: spacingBase };
+    for (const [name, value] of Object.entries(vars)) {
+        const level = /^--ng-spacing-([a-z]+)$/.exec(name);
+        if (level)
+            spacing[level[1]] = px(value, spacingBase);
+    }
+    const scale = {};
+    for (const level of Object.keys(mergeTypeScale(tokens.typeScale))) {
+        scale[level] = px(vars[`--ng-font-size-${level}`], fontSize);
+        const narrow = vars[`--ng-font-size-${level}-mobile`];
+        if (narrow)
+            scale[`${level}Mobile`] = px(narrow, fontSize);
+    }
+    return {
+        mode,
+        vars,
+        colors,
+        spacing,
+        radius: {
+            sm: px(vars['--ng-radius-sm'], 2),
+            md: px(vars['--ng-radius-md'], 4),
+            lg: px(vars['--ng-radius-lg'], 12),
+            pill: px(vars['--ng-radius-pill'], 999)
+        },
+        font: {
+            family: vars['--ng-font'] ?? tokens.fontFamily,
+            headingFamily: vars['--ng-font-heading'] ?? tokens.fontFamily,
+            size: fontSize,
+            weight: vars['--ng-font-weight'] ?? tokens.fontWeight,
+            scale
+        },
+        shadow: {
+            none: {},
+            sm: parseShadow(vars['--ng-shadow-sm']),
+            md: parseShadow(vars['--ng-shadow-md']),
+            lg: parseShadow(vars['--ng-shadow-lg'])
+        }
+    };
+}
+/* ---- compose-native-style.ts ---- */
+const TEXT_KEYS = new Set(['color', 'fontFamily', 'fontSize', 'fontStyle', 'fontWeight', 'letterSpacing', 'lineHeight', 'textAlign', 'textDecorationLine', 'textTransform']);
+const RENAMED_KEYS = { background: 'backgroundColor', textDecoration: 'textDecorationLine' };
+const IGNORED_KEYS = new Set(['boxShadow', 'transition', 'cursor', 'boxSizing', 'whiteSpace', 'wordBreak', 'textOverflow', 'backdropFilter', 'filter']);
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSet = (value) => value !== undefined && value !== null && value !== '' && !(typeof value === 'string' && value.includes('{{'));
+export function resolveThemeToken(value, theme) {
+    return value.replace(/var\((--[a-z0-9-]+)(?:\s*,\s*([^)]+))?\)/g, (whole, name, fallback) => theme.vars[name] ?? fallback?.trim() ?? whole);
+}
+const asText = (value, theme) => isSet(value) ? resolveThemeToken(String(value), theme) : undefined;
+const composeRadius = (value, shell, theme, context) => {
+    if (!isSet(value))
+        return;
+    const preset = theme.radius[String(value)];
+    if (preset !== undefined) {
+        shell.borderRadius = preset;
+        return;
+    }
+    const parts = resolveThemeToken(String(value), theme).trim().split(/\s+/);
+    if (parts.length === 1) {
+        const radius = parsePanelLength(parts[0], context);
+        if (typeof radius === 'number')
+            shell.borderRadius = radius;
+        return;
+    }
+    const corners = ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius'];
+    corners.forEach((corner, index) => {
+        const radius = parseLength(parts[index] ?? parts[index % parts.length], context);
+        if (typeof radius === 'number')
+            shell[corner] = radius;
+    });
+};
+const composeBorders = (surface, shell, theme, context) => {
+    const sides = [
+        ['borderTop', 'borderTopWidth', 'borderTopColor'],
+        ['borderRight', 'borderRightWidth', 'borderRightColor'],
+        ['borderBottom', 'borderBottomWidth', 'borderBottomColor'],
+        ['borderLeft', 'borderLeftWidth', 'borderLeftColor']
+    ];
+    let wrote = false;
+    for (const [field, widthKey, colorKey] of sides) {
+        if (!isSet(surface[field]))
+            continue;
+        const border = parseBorderShorthand(resolveThemeToken(String(surface[field]), theme), context);
+        if (!border)
+            continue;
+        wrote = true;
+        shell[widthKey] = border.width;
+        if (border.color)
+            shell[colorKey] = border.color;
+        if (border.style !== 'solid' && !shell.borderStyle)
+            shell.borderStyle = border.style;
+    }
+    if (wrote)
+        return;
+    const width = Number(surface.borderWidth);
+    const color = asText(surface.borderColor, theme);
+    const style = asText(surface.borderStyle, theme);
+    if (Number.isFinite(width) && isSet(surface.borderWidth)) {
+        shell.borderWidth = width;
+        if (width > 0) {
+            shell.borderColor = color ?? theme.colors.borderPrimary;
+            if (style && style !== 'solid')
+                shell.borderStyle = style;
+        }
+        return;
+    }
+    if (color || style) {
+        shell.borderWidth = 1;
+        shell.borderColor = color ?? theme.colors.borderPrimary;
+        if (style && style !== 'solid')
+            shell.borderStyle = style;
+    }
+};
+const composeSurface = (surface, shell, theme, context) => {
+    const background = asText(surface.background, theme);
+    if (background)
+        shell.backgroundColor = background;
+    composeRadius(surface.radius, shell, theme, context);
+    composeBorders(surface, shell, theme, context);
+    if (isSet(surface.shadow)) {
+        const raw = String(surface.shadow);
+        const key = raw;
+        if (!theme.shadow[key] && (raw.includes(',') || raw.includes('inset'))) {
+            context.warnings?.push(`shadow: RN tek katman taşır, ilk katman uygulandı (${raw})`);
+        }
+        Object.assign(shell, theme.shadow[key] ?? parseShadow(resolveThemeToken(raw, theme)));
+    }
+    const opacity = parseOpacity(surface.opacity);
+    if (opacity !== null)
+        shell.opacity = opacity;
+    if (isSet(surface.contentOverflow)) {
+        const overflow = String(surface.contentOverflow);
+        shell.overflow = overflow === 'visible' ? 'visible' : 'hidden';
+        if (overflow === 'auto')
+            context.warnings?.push('contentOverflow: auto — RN kaydırmayı bileşenin kendisi açar, kutu hidden yapıldı');
+    }
+};
+const composeTypography = (typography, text, theme, context) => {
+    const color = asText(typography.textColor, theme);
+    if (color)
+        text.color = color;
+    const family = parseFontFamily(asText(typography.fontFamily, theme));
+    if (family)
+        text.fontFamily = family;
+    const fontSize = parsePanelLength(typeof typography.fontSize === 'string' ? resolveThemeToken(typography.fontSize, theme) : typography.fontSize, context);
+    if (typeof fontSize === 'number')
+        text.fontSize = fontSize;
+    if (isSet(typography.fontWeight))
+        text.fontWeight = String(typography.fontWeight);
+    if (isSet(typography.fontStyle))
+        text.fontStyle = String(typography.fontStyle);
+    if (isSet(typography.textDecoration))
+        text.textDecorationLine = String(typography.textDecoration);
+    if (isSet(typography.textAlign))
+        text.textAlign = String(typography.textAlign);
+    const letterSpacing = parsePanelLength(typography.letterSpacing, context);
+    if (typeof letterSpacing === 'number')
+        text.letterSpacing = letterSpacing;
+    const lineHeight = parseLineHeight(typography.lineHeight, text.fontSize ?? context.base, context);
+    if (lineHeight !== null)
+        text.lineHeight = lineHeight;
+};
+const composeFreeStyle = (value, shell, text, theme, context) => {
+    if (!isPlainObject(value))
+        return;
+    for (const [rawKey, rawValue] of Object.entries(value)) {
+        if (!isSet(rawValue))
+            continue;
+        if (rawKey.startsWith('&') || rawKey.startsWith('--') || rawKey.startsWith(':')) {
+            context.warnings?.push(`${rawKey}: RN'de alt seçici yok, atlandı`);
+            continue;
+        }
+        const key = RENAMED_KEYS[rawKey] ?? rawKey;
+        if (IGNORED_KEYS.has(key))
+            continue;
+        const target = TEXT_KEYS.has(key) ? text : shell;
+        const resolved = typeof rawValue === 'string' ? resolveThemeToken(rawValue, theme) : rawValue;
+        if (typeof resolved === 'number') {
+            target[key] = resolved;
+            continue;
+        }
+        const length = key === 'fontWeight' || typeof resolved !== 'string' ? null : parseLength(resolved, { ...context, warnings: undefined });
+        target[key] = length ?? resolved;
+    }
+};
+export function composeNativeStyle(input, theme) {
+    const warnings = [];
+    const shell = {};
+    const text = {};
+    const context = { base: theme.font.size, root: theme.font.size, warnings };
+    composeFreeStyle(input.themeStyle, shell, text, theme, context);
+    if (isPlainObject(input.surfaceStyle))
+        composeSurface(input.surfaceStyle, shell, theme, context);
+    if (isPlainObject(input.typographyStyle))
+        composeTypography(input.typographyStyle, text, theme, context);
+    if (isPlainObject(input.hoverStyle) && Object.values(input.hoverStyle).some(isSet)) {
+        warnings.push('hoverStyle: dokunmatikte hover durumu yok, atlandı');
+    }
+    composeFreeStyle(input.style, shell, text, theme, context);
+    return { shell, text, warnings };
+}
+/**
+ * Bir düğümün mobil çizerdeki stili (`NativeRenderer` → `composeNativeStyle(props, theme)`). Çizer
+ * düğümün KENDİ prop'larını derler; temanın `componentStyles`/preset katmanı mobil çizerde henüz
+ * uygulanmıyor, bu yüzden rapora da girmez. İfadeye bağlı prop çalışma anında çözülür, burada yok.
+ */
+export function nodeNativeStyle(node, theme) {
+    const props = node.props;
+    const group = (name) => {
+        const value = rawProp(props, name);
+        return isPlainObject(value) ? value : null;
+    };
+    return composeNativeStyle({
+        surfaceStyle: group('surfaceStyle'),
+        typographyStyle: group('typographyStyle'),
+        hoverStyle: group('hoverStyle'),
+        style: rawProp(props, 'style')
+    }, theme);
+}

package/dist/knowledge/themeResolve.js

@@ -332,8 +332,8 @@ export function buildSpacingScaleVars(scale) {
         .join('\n\t');
 }
 /**
- * Bir seviyenin mobil karşılığının masaüstüne oranı — bugünkü breakpoint değerlerinden türer.
- * Kullanıcı tek çarpan ayarlar, mobil ona orantılı hareket eder.
+ * Bir seviyenin dar ekran karşılığının masaüstüne oranı — bugünkü breakpoint değerlerinden türer.
+ * Kullanıcı tek çarpan ayarlar, dar ekran ona orantılı hareket eder.
  */
 const TYPE_SCALE_MOBILE_RATIO = {
     h1: 1.7 / 2.25,
@@ -363,7 +363,7 @@ export function mergeTypeScale(overrides) {
     }
     return result;
 }
-/** Ölçekten `--ng-font-size-*` değişkenlerini üretir (masaüstü + mobil). */
+/** Ölçekten `--ng-font-size-*` değişkenlerini üretir (masaüstü + dar ekran). */
 export function buildTypeScaleVars(scale) {
     const lines = [];
     for (const [level, factor] of Object.entries(scale)) {