@a3s-lab/office 0.1.0

package/dist/0~work-presentation-charts.js

@@ -0,0 +1,442 @@
+import { workSpreadsheetChartSupportsErrorBars, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartLayout, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartSupportsSeriesAnalysis, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetTrendline } from "./8715.js";
+import { createOfficeId as createWorkId } from "./1134.js";
+function chartTypeWithAxes(type) {
+    return 'pie' === type || 'doughnut' === type ? 'column' : type;
+}
+function semanticPresentationChartAxes(chart) {
+    const sourceType = chartTypeWithAxes(chart.type);
+    const normalized = normalizeWorkSpreadsheetChartAxes(chart.axes, sourceType, false);
+    const categoryPosition = 'bar' === sourceType ? 'left' : 'bottom';
+    const valuePosition = 'bar' === sourceType ? 'bottom' : 'left';
+    const legacyCategoryTitle = chart.categoryAxisTitle?.trim();
+    const legacyValueTitle = chart.valueAxisTitle?.trim();
+    const categoryOrX = mergeLegacyTitle(normalized?.[categoryPosition], legacyCategoryTitle);
+    const valueOrY = mergeLegacyTitle(normalized?.[valuePosition], legacyValueTitle);
+    return {
+        categoryOrX,
+        valueOrY
+    };
+}
+function mergeLegacyTitle(axis, legacyTitle) {
+    if (!legacyTitle || axis?.title?.trim() || axis?.titleReference?.trim()) return axis;
+    return {
+        ...axis,
+        title: legacyTitle
+    };
+}
+function presentationChartAxes(chart) {
+    if ('pie' === chart.type || 'doughnut' === chart.type) return;
+    return presentationChartAxesForType(chart, chart.type);
+}
+function presentationChartAxesForType(chart, targetType) {
+    const { categoryOrX, valueOrY } = semanticPresentationChartAxes(chart);
+    if (!categoryOrX && !valueOrY) return;
+    const normalizedTargetType = chartTypeWithAxes(targetType);
+    const source = 'bar' === normalizedTargetType ? {
+        ...valueOrY ? {
+            bottom: valueOrY
+        } : {},
+        ...categoryOrX ? {
+            left: categoryOrX
+        } : {}
+    } : {
+        ...categoryOrX ? {
+            bottom: categoryOrX
+        } : {},
+        ...valueOrY ? {
+            left: valueOrY
+        } : {}
+    };
+    return normalizeWorkSpreadsheetChartAxes(source, normalizedTargetType, false);
+}
+function withPresentationChartAxes(chart, axes) {
+    const { axes: _axes, categoryAxisTitle: _categoryAxisTitle, valueAxisTitle: _valueAxisTitle, ...base } = chart;
+    const normalized = normalizeWorkSpreadsheetChartAxes(axes, chartTypeWithAxes(chart.type), false);
+    return normalized ? {
+        ...base,
+        axes: normalized
+    } : base;
+}
+const MAX_CHART_ITEMS = 256;
+const chartNumberFormatter = new Intl.NumberFormat('zh-CN', {
+    maximumFractionDigits: 6
+});
+const chartPercentageFormatter = new Intl.NumberFormat('zh-CN', {
+    maximumFractionDigits: 1
+});
+function createPresentationChartElement() {
+    return {
+        id: createWorkId('element'),
+        type: 'chart',
+        x: 18,
+        y: 20,
+        width: 64,
+        height: 52,
+        text: '',
+        fontSize: 14,
+        color: '#172033',
+        fill: '#ffffff',
+        bold: false,
+        align: 'center',
+        borderColor: '#d9dee8',
+        borderWidth: 1,
+        altText: '季度数据图表',
+        chart: {
+            type: 'column',
+            title: '季度数据',
+            categories: [
+                '第一季度',
+                '第二季度',
+                '第三季度'
+            ],
+            series: [
+                {
+                    name: '系列 1',
+                    values: [
+                        32,
+                        48,
+                        61
+                    ]
+                }
+            ],
+            showLegend: true,
+            legendPosition: 'right'
+        }
+    };
+}
+function presentationChartTypeLabel(type) {
+    if ('bar' === type) return '条形图';
+    if ('line' === type) return '折线图';
+    if ('pie' === type) return '饼图';
+    if ('doughnut' === type) return '圆环图';
+    if ('area' === type) return '面积图';
+    if ('radar' === type) return '雷达图';
+    if ('scatter' === type) return '散点图';
+    if ('bubble' === type) return '气泡图';
+    return '柱形图';
+}
+function withPresentationChartType(chart, type) {
+    const { axes, bubbleScale, bubbleSizeRepresents, categoryAxisTitle, dataLabels, doughnutHoleSize, radarStyle, scatterStyle, series, showNegativeBubbles, valueAxisTitle, ...base } = chart;
+    const nextAxes = presentationChartAxesForType({
+        ...chart,
+        axes,
+        categoryAxisTitle,
+        valueAxisTitle
+    }, type);
+    const nextDataLabels = dataLabels ? normalizePresentationChartDataLabels(dataLabels, type) : void 0;
+    if (nextDataLabels && !presentationChartDataLabelsHaveContent(nextDataLabels)) nextDataLabels.showValue = true;
+    const nextCategories = presentationChartUsesNumericXAxis(type) && !presentationChartUsesNumericXAxis(chart.type) ? chart.categories.map((_, index)=>String(index + 1)) : chart.categories;
+    const nextSeries = series.map(({ bubbleSizes, errorBars, trendlines, ...current })=>({
+            ...current,
+            ...'bubble' === type ? {
+                bubbleSizes: bubbleSizes?.map(finitePresentationChartNumber) ?? current.values.map(()=>1)
+            } : {},
+            ...workSpreadsheetChartSupportsErrorBars(type) && errorBars?.length ? {
+                errorBars: normalizePresentationChartErrorBars(errorBars, type)
+            } : {},
+            ...workSpreadsheetChartSupportsTrendlines(type) && trendlines?.length ? {
+                trendlines: trendlines.map(normalizeWorkSpreadsheetTrendline)
+            } : {}
+        }));
+    return withPresentationChartLayout({
+        ...base,
+        categories: nextCategories,
+        series: nextSeries,
+        type,
+        ...nextAxes ? {
+            axes: nextAxes
+        } : {},
+        ...nextDataLabels ? {
+            dataLabels: nextDataLabels
+        } : {},
+        ...'doughnut' === type ? {
+            doughnutHoleSize: normalizeDoughnutHoleSize(doughnutHoleSize)
+        } : {},
+        ...'radar' === type ? {
+            radarStyle: normalizeRadarStyle(radarStyle)
+        } : {},
+        ...'scatter' === type ? {
+            scatterStyle: normalizePresentationScatterStyle(scatterStyle)
+        } : {},
+        ...'bubble' === type ? {
+            bubbleScale: normalizePresentationBubbleScale(bubbleScale),
+            showNegativeBubbles: true === showNegativeBubbles,
+            bubbleSizeRepresents: normalizePresentationBubbleSizeRepresents(bubbleSizeRepresents)
+        } : {}
+    });
+}
+function withPresentationChartLayout(chart, change = {}) {
+    const source = {
+        ...chart,
+        ...change
+    };
+    const normalized = normalizeWorkSpreadsheetChartLayout(source);
+    const supportsAnalysis = workSpreadsheetChartSupportsSeriesAnalysis({
+        ...source,
+        ...normalized
+    });
+    const { gapWidth: _gapWidth, grouping: _grouping, legendOverlay: _legendOverlay, legendPosition: _legendPosition, overlap: _overlap, series: _series, smoothLines: _smoothLines, ...base } = source;
+    const series = source.series.map((item)=>{
+        const { errorBars, style, trendlines, ...seriesBase } = item;
+        const normalizedStyle = normalizePresentationChartSeriesStyle(style, source.type);
+        return {
+            ...seriesBase,
+            ...normalizedStyle ? {
+                style: normalizedStyle
+            } : {},
+            ...supportsAnalysis && workSpreadsheetChartSupportsErrorBars(source.type) && errorBars?.length ? {
+                errorBars: normalizePresentationChartErrorBars(errorBars, source.type)
+            } : {},
+            ...supportsAnalysis && workSpreadsheetChartSupportsTrendlines(source.type) && trendlines?.length ? {
+                trendlines: trendlines.map(normalizeWorkSpreadsheetTrendline)
+            } : {}
+        };
+    });
+    return {
+        ...base,
+        series,
+        ...void 0 !== source.legendPosition ? {
+            legendPosition: normalized.legendPosition
+        } : {},
+        ...void 0 !== source.legendOverlay ? {
+            legendOverlay: normalized.legendOverlay
+        } : {},
+        ...void 0 !== normalized.grouping && void 0 !== source.grouping ? {
+            grouping: normalized.grouping
+        } : {},
+        ...void 0 !== normalized.gapWidth && void 0 !== source.gapWidth ? {
+            gapWidth: normalized.gapWidth
+        } : {},
+        ...void 0 !== normalized.overlap && void 0 !== source.overlap ? {
+            overlap: normalized.overlap
+        } : {},
+        ...void 0 !== normalized.smoothLines && void 0 !== source.smoothLines ? {
+            smoothLines: normalized.smoothLines
+        } : {}
+    };
+}
+function normalizePresentationChartSeriesStyle(style, type) {
+    const normalized = normalizeWorkSpreadsheetChartSeriesStyle(style);
+    if (!normalized) return;
+    if (presentationChartSupportsSeriesMarkers(type)) return normalized;
+    const { marker: _marker, ...withoutMarker } = normalized;
+    return Object.keys(withoutMarker).length ? withoutMarker : void 0;
+}
+function withPresentationChartSeriesStyle(chart, seriesIndex, style) {
+    return withPresentationChartLayout({
+        ...chart,
+        series: chart.series.map((series, index)=>index === seriesIndex ? {
+                ...series,
+                style: normalizePresentationChartSeriesStyle(style, chart.type)
+            } : series)
+    });
+}
+function presentationChartSupportsSeriesMarkers(type) {
+    return 'line' === type || 'radar' === type || 'scatter' === type;
+}
+function parsePresentationChartCategories(value) {
+    return value.split(/\r?\n/).map((item)=>item.trim().slice(0, 255)).filter(Boolean).slice(0, MAX_CHART_ITEMS);
+}
+function parsePresentationChartValueDraft(value) {
+    const items = value.split(/[\s,;，；]+/).map((item)=>item.trim()).filter(Boolean).slice(0, MAX_CHART_ITEMS);
+    const values = items.map(Number);
+    return values.every(Number.isFinite) ? values : null;
+}
+function createPresentationChartSeries(chart) {
+    const values = Array.from({
+        length: Math.max(1, chart.categories.length)
+    }, ()=>0);
+    return {
+        name: `系列 ${chart.series.length + 1}`,
+        values,
+        ...'bubble' === chart.type ? {
+            bubbleSizes: values.map(()=>1)
+        } : {}
+    };
+}
+function withPresentationChartSeriesAnalysis(chart, seriesIndex, analysis) {
+    return withPresentationChartLayout({
+        ...chart,
+        series: chart.series.map((series, index)=>{
+            if (index !== seriesIndex) return series;
+            const { errorBars: _errorBars, trendlines: _trendlines, ...base } = series;
+            const errorBars = workSpreadsheetChartSupportsErrorBars(chart.type) ? normalizePresentationChartErrorBars(analysis.errorBars ?? [], chart.type) : void 0;
+            const trendlines = workSpreadsheetChartSupportsTrendlines(chart.type) ? analysis.trendlines?.map(normalizeWorkSpreadsheetTrendline) : void 0;
+            return {
+                ...base,
+                ...errorBars?.length ? {
+                    errorBars
+                } : {},
+                ...trendlines?.length ? {
+                    trendlines
+                } : {}
+            };
+        })
+    });
+}
+function presentationChartTrendlineCount(chart) {
+    if (!workSpreadsheetChartSupportsSeriesAnalysis(chart) || !workSpreadsheetChartSupportsTrendlines(chart.type)) return 0;
+    return chart.series.reduce((count, series)=>count + (series.trendlines?.length ?? 0), 0);
+}
+function presentationChartErrorBarCount(chart) {
+    if (!workSpreadsheetChartSupportsSeriesAnalysis(chart) || !workSpreadsheetChartSupportsErrorBars(chart.type)) return 0;
+    return chart.series.reduce((count, series)=>count + (series.errorBars?.length ?? 0), 0);
+}
+function normalizePresentationChartErrorBars(sources, type) {
+    const directions = new Set();
+    return sources.flatMap((source)=>{
+        const errorBars = normalizeWorkSpreadsheetErrorBars(source, type);
+        if (directions.has(errorBars.direction)) return [];
+        directions.add(errorBars.direction);
+        return [
+            errorBars
+        ];
+    });
+}
+function normalizeDoughnutHoleSize(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.min(90, Math.max(10, Math.round(number))) : 50;
+}
+function normalizeRadarStyle(value) {
+    return 'marker' === value || 'filled' === value ? value : 'standard';
+}
+function normalizePresentationScatterStyle(value) {
+    return 'marker' === value || 'line' === value || 'smooth' === value || 'smoothMarker' === value || 'lineMarker' === value ? value : 'lineMarker';
+}
+function normalizePresentationBubbleScale(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.min(300, Math.max(5, Math.round(number))) : 100;
+}
+function normalizePresentationBubbleSizeRepresents(value) {
+    return 'width' === value ? 'width' : 'area';
+}
+function presentationChartUsesNumericXAxis(type) {
+    return 'scatter' === type || 'bubble' === type;
+}
+function presentationChartXValues(chart) {
+    const length = Math.max(chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    return Array.from({
+        length
+    }, (_, index)=>{
+        const value = Number(chart.categories[index]);
+        return Number.isFinite(value) ? value : index + 1;
+    });
+}
+function presentationChartBubbleSizes(series) {
+    return series.values.map((_, index)=>finitePresentationChartNumber(series.bubbleSizes?.[index] ?? 1));
+}
+function normalizePresentationChartLegendPosition(value) {
+    return 'left' === value || 'top' === value || 'bottom' === value || 'topRight' === value || 'right' === value ? value : 'right';
+}
+function presentationChartLegendPositionLabel(position) {
+    if ('left' === position) return '左侧';
+    if ('top' === position) return '顶部';
+    if ('bottom' === position) return '底部';
+    if ('topRight' === position) return '右上角';
+    return '右侧';
+}
+function presentationChartShowsLegend(chart) {
+    return chart.showLegend ?? chart.series.length > 1;
+}
+function presentationChartSupportsAxisTitles(chart) {
+    return 'pie' !== chart.type && 'doughnut' !== chart.type;
+}
+function presentationChartDataLabelPositions(type) {
+    if ('pie' === type || 'doughnut' === type) return [
+        'bestFit',
+        'center',
+        'insideEnd',
+        'outsideEnd'
+    ];
+    if ('line' === type || 'radar' === type || 'scatter' === type || 'bubble' === type) return [
+        'above',
+        'below',
+        'left',
+        'right',
+        'center'
+    ];
+    return [
+        'outsideEnd',
+        'insideEnd',
+        'insideBase',
+        'center'
+    ];
+}
+function normalizePresentationChartDataLabelPosition(value, type) {
+    const positions = presentationChartDataLabelPositions(type);
+    if ('string' == typeof value && positions.includes(value)) return value;
+    if ('pie' === type || 'doughnut' === type) return 'bestFit';
+    if ('line' === type || 'radar' === type || 'scatter' === type || 'bubble' === type) return 'above';
+    return 'outsideEnd';
+}
+function normalizePresentationChartDataLabels(source, type) {
+    const separator = 'string' == typeof source.separator ? source.separator.slice(0, 64) : void 0;
+    return {
+        ...true === source.showValue ? {
+            showValue: true
+        } : {},
+        ...true === source.showCategoryName ? {
+            showCategoryName: true
+        } : {},
+        ...true === source.showSeriesName ? {
+            showSeriesName: true
+        } : {},
+        ...true === source.showPercentage && ('pie' === type || 'doughnut' === type) ? {
+            showPercentage: true
+        } : {},
+        ...true === source.showBubbleSize && 'bubble' === type ? {
+            showBubbleSize: true
+        } : {},
+        ...void 0 !== separator ? {
+            separator
+        } : {},
+        position: normalizePresentationChartDataLabelPosition(source.position, type)
+    };
+}
+function withPresentationChartDataLabels(chart, dataLabels) {
+    const { dataLabels: _current, ...base } = chart;
+    return dataLabels ? {
+        ...base,
+        dataLabels: normalizePresentationChartDataLabels(dataLabels, chart.type)
+    } : base;
+}
+function presentationChartHasDataLabels(chart) {
+    return void 0 !== chart.dataLabels;
+}
+function presentationChartDataLabelPositionLabel(position) {
+    if ('center' === position) return '居中';
+    if ('insideBase' === position) return '内侧基部';
+    if ('insideEnd' === position) return '内侧末端';
+    if ('outsideEnd' === position) return '外侧末端';
+    if ('left' === position) return '左侧';
+    if ('right' === position) return '右侧';
+    if ('above' === position) return '上方';
+    if ('below' === position) return '下方';
+    return '最佳匹配';
+}
+function presentationChartDataLabelText(chart, seriesIndex, pointIndex) {
+    const series = chart.series[seriesIndex];
+    if (!series || !chart.dataLabels) return '';
+    const labels = normalizePresentationChartDataLabels(chart.dataLabels, chart.type);
+    const parts = [];
+    if (labels.showSeriesName) parts.push(series.name.trim() || `系列 ${seriesIndex + 1}`);
+    if (labels.showCategoryName) parts.push(chart.categories[pointIndex]?.trim() || `分类 ${pointIndex + 1}`);
+    if (labels.showValue) parts.push(formatPresentationChartNumber(series.values[pointIndex]));
+    if (labels.showPercentage) {
+        const values = series.values.map((value)=>Math.max(0, finitePresentationChartNumber(value)));
+        const total = values.reduce((sum, value)=>sum + value, 0);
+        if (total > 0) parts.push(`${chartPercentageFormatter.format(values[pointIndex] / total * 100)}%`);
+    }
+    if (labels.showBubbleSize) parts.push(formatPresentationChartNumber(series.bubbleSizes?.[pointIndex]));
+    return parts.join(labels.separator ?? ', ');
+}
+function presentationChartDataLabelsHaveContent(labels) {
+    return Boolean(labels.showValue || labels.showCategoryName || labels.showSeriesName || labels.showPercentage || labels.showBubbleSize);
+}
+function formatPresentationChartNumber(value) {
+    return chartNumberFormatter.format(finitePresentationChartNumber(value));
+}
+function finitePresentationChartNumber(value) {
+    return Number.isFinite(value) ? Number(value) : 0;
+}
+export { createPresentationChartElement, createPresentationChartSeries, normalizeDoughnutHoleSize, normalizePresentationBubbleScale, normalizePresentationBubbleSizeRepresents, normalizePresentationChartDataLabelPosition, normalizePresentationChartDataLabels, normalizePresentationChartLegendPosition, normalizePresentationChartSeriesStyle, normalizePresentationScatterStyle, normalizeRadarStyle, parsePresentationChartCategories, parsePresentationChartValueDraft, presentationChartAxes, presentationChartBubbleSizes, presentationChartDataLabelPositionLabel, presentationChartDataLabelPositions, presentationChartDataLabelText, presentationChartErrorBarCount, presentationChartHasDataLabels, presentationChartLegendPositionLabel, presentationChartShowsLegend, presentationChartSupportsAxisTitles, presentationChartSupportsSeriesMarkers, presentationChartTrendlineCount, presentationChartTypeLabel, presentationChartUsesNumericXAxis, presentationChartXValues, withPresentationChartAxes, withPresentationChartDataLabels, withPresentationChartLayout, withPresentationChartSeriesAnalysis, withPresentationChartSeriesStyle, withPresentationChartType };

package/dist/0~work-presentation-transition.js

@@ -0,0 +1,38 @@
+const CARDINAL_DIRECTIONS = new Set([
+    'left',
+    'right',
+    'up',
+    'down'
+]);
+const SPLIT_DIRECTIONS = new Set([
+    'in',
+    'out'
+]);
+function createWorkSlideTransition(type, previous) {
+    const common = {
+        type,
+        speed: previous?.speed ?? 'medium',
+        advanceOnClick: previous?.advanceOnClick ?? true,
+        advanceAfterMs: previous?.advanceAfterMs
+    };
+    if ('push' === type || 'wipe' === type) return {
+        ...common,
+        direction: previous?.direction && CARDINAL_DIRECTIONS.has(previous.direction) ? previous.direction : 'left'
+    };
+    if ('split' === type) return {
+        ...common,
+        direction: previous?.direction && SPLIT_DIRECTIONS.has(previous.direction) ? previous.direction : 'out',
+        orientation: previous?.orientation ?? 'horizontal'
+    };
+    return common;
+}
+function slideTransitionDurationMilliseconds(transition) {
+    if (transition?.speed === 'fast') return 500;
+    if (transition?.speed === 'slow') return 2000;
+    return 1000;
+}
+function workSlideTransitionsEqual(left, right) {
+    if (!left || !right) return left === right;
+    return left.type === right.type && left.speed === right.speed && left.direction === right.direction && left.orientation === right.orientation && left.advanceOnClick === right.advanceOnClick && left.advanceAfterMs === right.advanceAfterMs;
+}
+export { createWorkSlideTransition, slideTransitionDurationMilliseconds, workSlideTransitionsEqual };

package/dist/0~work-presentation-visual-scale.js

@@ -0,0 +1,38 @@
+function scaledPresentationVisuals(element, scale) {
+    const fontSize = presentationElementScalesTypography(element) ? scaledPresentationFontSize(element.fontSize, scale) : element.fontSize;
+    const borderWidth = void 0 === element.borderWidth ? void 0 : scaledPresentationBorderWidth(element.borderWidth, scale);
+    const textRuns = scaledPresentationTextRuns(element, scale);
+    return {
+        fontSize,
+        ...void 0 !== borderWidth ? {
+            borderWidth
+        } : {},
+        ...textRuns !== element.textRuns ? {
+            textRuns
+        } : {}
+    };
+}
+function presentationElementScalesTypography(element) {
+    return 'text' === element.type || 'shape' === element.type || 'table' === element.type || Boolean(element.text || element.textRuns?.length);
+}
+function scaledPresentationTextRuns(element, scale) {
+    if (!element.textRuns?.some((run)=>void 0 !== run.fontSize)) return element.textRuns;
+    return element.textRuns.map((run)=>void 0 === run.fontSize ? run : {
+            ...run,
+            fontSize: scaledPresentationFontSize(run.fontSize, scale)
+        });
+}
+function scaledPresentationFontSize(value, scale) {
+    return roundedPresentationMetric(clamp(value * scale, 1, 400));
+}
+function scaledPresentationBorderWidth(value, scale) {
+    if (0 === value) return 0;
+    return roundedPresentationMetric(Math.max(0.1, value * scale));
+}
+function roundedPresentationMetric(value) {
+    return Math.round(1000 * value) / 1000;
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+export { scaledPresentationVisuals };

package/dist/0~work-spreadsheet-formula-support.js

@@ -0,0 +1,9 @@
+import { locale } from "@fortune-sheet/core";
+import { spreadsheetFormulaFunctions } from "./8715.js";
+const FORTUNE_SUPPORTED_FUNCTIONS = new Set(locale({
+    lang: 'en'
+}).functionlist.map((item)=>item.n.toUpperCase()));
+function unsupportedSpreadsheetFormulaFunctions(formula) {
+    return spreadsheetFormulaFunctions(formula).filter((name)=>!FORTUNE_SUPPORTED_FUNCTIONS.has(name));
+}
+export { unsupportedSpreadsheetFormulaFunctions };