Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

9.4 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import type { IDocumentSkeletonBoundingBox, IDocumentSkeletonFontStyle } from '../../../basics/i-document-skeleton-cached';
import { DocumentFlavor } from '@univerjs/core';
import { describe, expect, it } from 'vitest';
import { applyFontMetricCompatibility, getDocumentCompatibilityPolicy } from '../document-compatibility';

const fontStyle = {
    fontString: 'normal bold 24pt "Calibri", Arial',
    fontSize: 24,
    originFontSize: 24,
    fontFamily: '"Calibri", Arial',
    fontCache: 'normal bold 24pt "Calibri"',
} as IDocumentSkeletonFontStyle;

const bBox = {
    width: 16,
    ba: 30,
    bd: 9,
    aba: 30,
    abd: 9,
    sp: 0,
    sbr: 0.6,
    sbo: 1,
    spr: 0.6,
    spo: 1,
} as IDocumentSkeletonBoundingBox;

describe('document compatibility policy', () => {
    it.each([7.5, 12])('matches native Word YaHei single spacing at %s pt without changing ink metrics', (fontSize) => {
        const em = fontSize / 0.75;
        const measured = { ...bBox, ba: em * 2167 / 2048, bd: em * 536 / 2048, normalLineHeight: em * 2703 / 2048 };
        const traditional = getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL);
        for (const fontFamily of ['Microsoft YaHei', '"微软雅黑", Arial, 微软雅黑']) {
            const style = { ...fontStyle, fontSize, originFontSize: fontSize, fontFamily };
            for (const content of ['中', 'H']) {
                const actual = applyFontMetricCompatibility(content, style, measured, traditional);
                // Native PDF coordinates at 96 DPI; tolerate Word's sub-point rounding.
                expect(Math.abs(actual.normalLineHeight! - (fontSize === 7.5 ? 17.12 : 27.52))).toBeLessThan(0.1);
                expect({ ...actual, normalLineHeight: measured.normalLineHeight }).toEqual(measured);
                expect(applyFontMetricCompatibility(content, style, measured, getDocumentCompatibilityPolicy(DocumentFlavor.MODERN))).toBe(measured);
            }
            const larger = { ...measured, normalLineHeight: 60 };
            expect(applyFontMetricCompatibility('H', style, larger, traditional)).toBe(larger);
            const substituted = { ...measured, ba: em, bd: 0 };
            expect(applyFontMetricCompatibility('H', style, substituted, traditional)).toBe(substituted);
            expect(applyFontMetricCompatibility('H', { ...style, fontFamily: 'Arial, Microsoft YaHei' }, measured, traditional)).toBe(measured);
            expect(applyFontMetricCompatibility('H', { ...style, fontFamily: 'Microsoft YaHei UI' }, measured, traditional)).toBe(measured);
        }
    });

    it.each([11, 16])('retains Word MS Gothic auto-leading at %s pt without enlarging the ink box', (fontSize) => {
        const em = fontSize / 0.75;
        const style = { ...fontStyle, fontSize, originFontSize: fontSize, fontFamily: '"MS Gothic", Arial' };
        const measured = { ...bBox, ba: em * 220 / 256, bd: em * 36 / 256, normalLineHeight: em };
        for (const content of ['☐', 'M']) {
            const actual = applyFontMetricCompatibility(content, style, measured, getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL));
            // Native Word PDF row heights, excluding the 0.5pt table border, at 96 DPI.
            expect(actual.normalLineHeight).toBeCloseTo(fontSize === 11 ? 19.01334 : 27.65334, 1);
            expect({ ...actual, normalLineHeight: em }).toEqual(measured);
            expect(applyFontMetricCompatibility(content, style, measured, getDocumentCompatibilityPolicy(DocumentFlavor.MODERN))).toBe(measured);
        }
        expect(applyFontMetricCompatibility(
            'M',
            { ...style, fontFamily: 'Arial, "MS Gothic"' },
            measured,
            getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL)
        )).toBe(measured);
    });

    it.each([
        { content: '中', measured: 13.329986572265623, expected: 40 / 3 },
        { content: '(', measured: 13.329986572265623, expected: 40 / 3 },
        { content: '𠀀', measured: 13.329986572265623, expected: 40 / 3 },
        { content: 'カ', measured: 20 / 3, expected: 20 / 3 },
        { content: '中', measured: 12.5, expected: 12.5 },
        { content: 'A', measured: 13.33, expected: 13.33 },
        { content: '中文', measured: 13.33, expected: 13.33 },
    ])('recovers fractional-em CJK advances without changing proportional glyphs: $content/$measured', ({ content, measured, expected }) => {
        const measuredBox = { ...bBox, width: measured };
        const style = { ...fontStyle, fontSize: 10, originFontSize: 10, fontFamily: 'Microsoft YaHei' };
        const traditional = applyFontMetricCompatibility(content, style, measuredBox, getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL));
        expect(traditional.width).toBeCloseTo(expected, 10);
        expect({ ...traditional, width: measured }).toEqual(measuredBox);
        expect(measuredBox.width).toBe(measured);
        expect(applyFontMetricCompatibility(content, style, measuredBox, getDocumentCompatibilityPolicy(DocumentFlavor.MODERN)))
            .toBe(measuredBox);
    });

    it('selects DrawingML font metrics without changing existing document flavors', () => {
        const policy = getDocumentCompatibilityPolicy(DocumentFlavor.DRAWINGML);
        expect(policy.mode).toBe('drawingml');
        expect(applyFontMetricCompatibility('5', fontStyle, bBox, policy)).toEqual(bBox);
        for (const flavor of [undefined, DocumentFlavor.UNSPECIFIED, DocumentFlavor.MODERN, DocumentFlavor.TRADITIONAL]) {
            expect(getDocumentCompatibilityPolicy(flavor).mode).not.toBe('drawingml');
        }
    });
    it('applies traditional Word font metric width rules without changing modern documents', () => {
        const traditional = getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL);
        const modern = getDocumentCompatibilityPolicy(DocumentFlavor.MODERN);

        expect(applyFontMetricCompatibility('5', fontStyle, bBox, traditional).width).toBeCloseTo(14.72);
        expect(applyFontMetricCompatibility('5', fontStyle, bBox, modern).width).toBe(16);
    });

    it('preserves measured Arial advances instead of narrowing Latin text in traditional documents', () => {
        const normalArial = {
            ...fontStyle,
            fontString: 'normal normal 11.5pt Arial',
            fontSize: 11.5,
            originFontSize: 11.5,
            fontFamily: 'Arial',
            fontCache: 'normal normal 11.5pt Arial',
        } as IDocumentSkeletonFontStyle;
        const boldArial = {
            ...normalArial,
            fontString: 'normal bold 11.5pt Arial',
            fontCache: 'normal bold 11.5pt Arial',
        } as IDocumentSkeletonFontStyle;
        const browserMeasuredGlyph = { ...bBox, width: 10 };
        const traditional = getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL);
        const modern = getDocumentCompatibilityPolicy(DocumentFlavor.MODERN);

        for (const content of ['A', '0', '1', '8', ' ', '“']) {
            expect(applyFontMetricCompatibility(content, normalArial, browserMeasuredGlyph, traditional)).toBe(browserMeasuredGlyph);
        }
        expect(applyFontMetricCompatibility('A', boldArial, browserMeasuredGlyph, traditional).width).toBe(10);
        expect(applyFontMetricCompatibility('A', normalArial, browserMeasuredGlyph, modern).width).toBe(10);
        expect(applyFontMetricCompatibility('中', normalArial, browserMeasuredGlyph, traditional).width).toBe(10);
    });

    it('applies the traditional SimSun width policy when it is the East Asia fallback family', () => {
        const simSunFallback = {
            ...fontStyle,
            fontString: 'normal normal 12pt "Times New Roman", 宋体',
            fontSize: 12,
            originFontSize: 12,
            fontFamily: '"Times New Roman", 宋体',
            fontCache: 'normal normal 12pt "Times New Roman", 宋体',
        } as IDocumentSkeletonFontStyle;
        const traditional = getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL);

        expect(applyFontMetricCompatibility('中', simSunFallback, { ...bBox, width: 10 }, traditional).width)
            .toBeCloseTo(9.7);
    });

    it('keeps traditional layout behavior while allowing font metric scaling to be disabled', () => {
        const policy = getDocumentCompatibilityPolicy(DocumentFlavor.TRADITIONAL, false);
        const simSunFallback = {
            ...fontStyle,
            fontString: 'normal normal 12pt "Times New Roman", 宋体',
            fontSize: 12,
            originFontSize: 12,
            fontFamily: '"Times New Roman", 宋体',
            fontCache: 'normal normal 12pt "Times New Roman", 宋体',
        } as IDocumentSkeletonFontStyle;

        expect(policy.mode).toBe('traditional');
        expect(policy.useWordStyleLineHeight).toBe(true);
        expect(applyFontMetricCompatibility('中', simSunFallback, { ...bBox, width: 10 }, policy).width).toBe(10);
    });
});