@a3s-lab/office 0.11.0 → 0.12.0

package/dist/4476.js

@@ -1,8 +1,8 @@
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
 import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS } from "./5184.js";
 import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
+import { sparseMatrixColumnCount, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, cloneSparseMatrix, formatSpreadsheetCellRanges, parseSpreadsheetCellRanges as work_spreadsheet_ranges_parseSpreadsheetCellRanges } from "./8715.js";
 import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
-import { formatSpreadsheetCellRanges, parseSpreadsheetCellRanges } from "./8715.js";
 import * as __rspack_external_yjs from "yjs";
 const MAX_POPULATED_CELLS = 1000000;
 const MAX_DENSE_MATRIX_CELLS = 1000000;
@@ -421,7 +421,7 @@ function assertCompatibleValue(previous, next, shared, label) {
 function spreadsheetCells(sheet) {
     const result = new Map();
     if (void 0 !== sheet.data) {
-        for (const [row, values] of sheet.data.entries())for (const [column, cell] of values.entries())if (null !== cell) result.set(`${row}:${column}`, cell);
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values))if (null !== cell) result.set(`${row}:${column}`, cell);
         return result;
     }
     for (const entry of sheet.celldata ?? [])if (null !== entry.v) result.set(`${entry.r}:${entry.c}`, entry.v);
@@ -531,7 +531,7 @@ function spreadsheetCellEntries(sheet) {
     if (!sheet) return [];
     const entries = [];
     if (void 0 !== sheet.data) {
-        for (const [row, values] of sheet.data.entries())for (const [column, cell] of values.entries())if (null !== cell) entries.push({
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values))if (null !== cell) entries.push({
             cell,
             column,
             coordinate: encodedCoordinate(row, column),
@@ -1305,7 +1305,8 @@ function defaultSheetProtectionAuthority(enabled = false) {
         editScenarios: 0,
         hintText: '',
         defaultSheetHintText: DEFAULT_PROTECTION_HINT,
-        allowRangeList: []
+        allowRangeList: [],
+        cellProtectionRanges: []
     };
 }
 function sheetProtectionAuthority(sheet) {
@@ -1335,9 +1336,23 @@ function normalizeSheetProtectionAuthority(source) {
         hintText: stringValue(authority.hintText),
         defaultSheetHintText: stringValue(authority.defaultSheetHintText) || DEFAULT_PROTECTION_HINT,
         allowRangeList: editableRangeList(authority.allowRangeList),
+        cellProtectionRanges: cellProtectionRangeList(authority.cellProtectionRanges),
         xlsxAttributes: stringRecord(authority.xlsxAttributes)
     };
 }
+function importedSheetProtectionAuthority(authority, cellProtectionRanges) {
+    if (!authority && !cellProtectionRanges.length) return;
+    const normalized = normalizeSheetProtectionAuthority(authority);
+    normalized.cellProtectionRanges = [
+        ...cellProtectionRanges,
+        ...normalized.allowRangeList.filter((range)=>!editableRangeRequiresCredentials(range)).flatMap((range)=>work_spreadsheet_ranges_parseSpreadsheetCellRanges(range.sqref) ?? []).map((range)=>({
+                range,
+                locked: false,
+                hidden: false
+            }))
+    ];
+    return normalized;
+}
 function withSheetProtection(sheet, enabled) {
     const authority = sheetProtectionAuthority(sheet);
     authority.sheet = enabled ? 1 : 0;
@@ -1359,73 +1374,56 @@ function withEditableRange(sheet, index, editableRange) {
     };
     if (null !== index && authority.allowRangeList[index]) authority.allowRangeList[index] = nextRange;
     else authority.allowRangeList.push(nextRange);
-    const ranges = parseSpreadsheetCellRanges(nextRange.sqref) ?? [];
-    return withAuthority(withCellProtection(sheet, ranges, false), authority);
+    const ranges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(nextRange.sqref) ?? [];
+    const next = withCellProtection(sheet, ranges, false);
+    const nextAuthority = sheetProtectionAuthority(next);
+    nextAuthority.allowRangeList = authority.allowRangeList;
+    return withAuthority(next, nextAuthority);
 }
 function withoutEditableRange(sheet, index) {
     const authority = sheetProtectionAuthority(sheet);
     const removed = authority.allowRangeList[index];
     if (!removed) return sheet;
     authority.allowRangeList.splice(index, 1);
-    const removedRanges = parseSpreadsheetCellRanges(removed.sqref) ?? [];
+    const removedRanges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(removed.sqref) ?? [];
     let next = withCellProtection(sheet, removedRanges, true);
-    for (const editableRange of authority.allowRangeList)if (!editableRangeRequiresCredentials(editableRange)) next = withCellProtection(next, parseSpreadsheetCellRanges(editableRange.sqref) ?? [], false);
-    return withAuthority(next, authority);
+    for (const editableRange of authority.allowRangeList)if (!editableRangeRequiresCredentials(editableRange)) next = withCellProtection(next, work_spreadsheet_ranges_parseSpreadsheetCellRanges(editableRange.sqref) ?? [], false);
+    const nextAuthority = sheetProtectionAuthority(next);
+    nextAuthority.allowRangeList = authority.allowRangeList;
+    return withAuthority(next, nextAuthority);
 }
 function withCellProtection(sheet, ranges, locked, hidden = false) {
     if (!ranges.length) return sheet;
-    const data = cloneMatrix(sheet.data);
+    const data = cloneSparseMatrix(sheet.data);
     let rowCount = Math.max(sheet.row ?? 0, data.length);
-    let columnCount = Math.max(sheet.column ?? 0, ...data.map((row)=>row.length));
+    let columnCount = Math.max(sheet.column ?? 0, sparseMatrixColumnCount(data));
     for (const range of ranges){
         rowCount = Math.max(rowCount, range.row[1] + 1);
         columnCount = Math.max(columnCount, range.column[1] + 1);
-        for(let row = range.row[0]; row <= range.row[1]; row += 1){
-            data[row] ??= [];
-            for(let column = range.column[0]; column <= range.column[1]; column += 1){
-                const cell = {
-                    ...data[row][column] ?? {}
-                };
-                cell.lo = locked ? 1 : 0;
-                if (hidden) cell.hi = 1;
-                else if (void 0 !== cell.hi) delete cell.hi;
-                data[row][column] = cell;
-            }
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(data))if (!(row < range.row[0]) && !(row > range.row[1])) for (const [column, source] of spreadsheet_sparse_sparseArrayEntries(values)){
+            if (column < range.column[0] || column > range.column[1]) continue;
+            const cell = {
+                ...source ?? {}
+            };
+            cell.lo = locked ? 1 : 0;
+            if (hidden) cell.hi = 1;
+            else if (void 0 !== cell.hi) delete cell.hi;
+            data[row][column] = cell;
         }
     }
     normalizeMatrix(data, rowCount, columnCount);
-    return {
+    const authority = sheetProtectionAuthority(sheet);
+    authority.cellProtectionRanges.push(...ranges.map((range)=>({
+            range,
+            locked,
+            hidden
+        })));
+    return withAuthority({
         ...sheet,
         row: rowCount,
         column: columnCount,
         data
-    };
-}
-function applySpreadsheetCellProtectionRanges(data, ranges, rowCount, columnCount) {
-    for (const item of ranges){
-        const lastRow = Math.min(item.range.row[1], rowCount - 1);
-        const lastColumn = Math.min(item.range.column[1], columnCount - 1);
-        for(let row = Math.max(0, item.range.row[0]); row <= lastRow; row += 1){
-            data[row] ??= [];
-            for(let column = Math.max(0, item.range.column[0]); column <= lastColumn; column += 1){
-                const cell = {
-                    ...data[row][column] ?? {}
-                };
-                cell.lo = item.locked ? 1 : 0;
-                if (item.hidden) cell.hi = 1;
-                else if (void 0 !== cell.hi) delete cell.hi;
-                data[row][column] = cell;
-            }
-        }
-    }
-}
-function applyPasswordlessEditableRanges(data, ranges, rowCount, columnCount) {
-    const protectionRanges = ranges.filter((range)=>!editableRangeRequiresCredentials(range)).flatMap((range)=>parseSpreadsheetCellRanges(range.sqref) ?? []).map((range)=>({
-            range,
-            locked: false,
-            hidden: false
-        }));
-    applySpreadsheetCellProtectionRanges(data, protectionRanges, rowCount, columnCount);
+    }, authority);
 }
 function editableRangeRequiresCredentials(range) {
     const attributes = range.xlsxAttributes ?? {};
@@ -1446,7 +1444,7 @@ function spreadsheetProtectionKey(sheets) {
     return sheets.map((sheet)=>{
         const authority = sheetProtectionAuthority(sheet);
         const cells = [];
-        for (const [row, values] of (sheet.data ?? []).entries())for (const [column, cell] of values.entries()){
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values)){
             const hidden = cell?.hi;
             if (cell?.lo !== void 0 || void 0 !== hidden) cells.push(`${row}_${column}:${cell?.lo ?? ''}:${hidden ?? ''}`);
         }
@@ -1471,7 +1469,7 @@ function editableRangeList(value) {
         if (!item || 'object' != typeof item) return [];
         const range = item;
         const sqref = stringValue(range.sqref);
-        if (!sqref || !parseSpreadsheetCellRanges(sqref)) return [];
+        if (!sqref || !work_spreadsheet_ranges_parseSpreadsheetCellRanges(sqref)) return [];
         return [
             {
                 name: stringValue(range.name) || `Range ${index + 1}`,
@@ -1483,21 +1481,40 @@ function editableRangeList(value) {
     });
 }
 function canonicalRangeReference(value) {
-    const ranges = parseSpreadsheetCellRanges(value);
+    const ranges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(value);
     return ranges ? formatSpreadsheetCellRanges(ranges) : value.trim();
 }
-function cloneMatrix(source) {
-    return (source ?? []).map((row)=>[
-            ...row
-        ]);
-}
 function normalizeMatrix(data, rows, columns) {
-    while(data.length < rows)data.push([]);
-    for(let index = 0; index < data.length; index += 1){
-        const row = data[index] ?? [];
-        data[index] = row;
-        while(row.length < columns)row.push(null);
-    }
+    data.length = Math.max(data.length, rows);
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(data))row.length = Math.max(row.length, columns);
+}
+function cellProtectionRangeList(value) {
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((item)=>{
+        if (!item || 'object' != typeof item) return [];
+        const candidate = item;
+        const range = candidate.range;
+        if (!range || !Array.isArray(range.row) || !Array.isArray(range.column) || range.row.length < 2 || range.column.length < 2 || ![
+            ...range.row,
+            ...range.column
+        ].every((index)=>Number.isSafeInteger(index) && index >= 0)) return [];
+        return [
+            {
+                range: {
+                    row: [
+                        Math.min(range.row[0], range.row[1]),
+                        Math.max(range.row[0], range.row[1])
+                    ],
+                    column: [
+                        Math.min(range.column[0], range.column[1]),
+                        Math.max(range.column[0], range.column[1])
+                    ]
+                },
+                locked: false !== candidate.locked,
+                hidden: true === candidate.hidden
+            }
+        ];
+    });
 }
 function flag(value, fallback) {
     if (1 === value || true === value || '1' === value) return 1;
@@ -2005,4 +2022,4 @@ function boundedInteger(value, minimum, maximum, fallback) {
 function boundedNumber(value, minimum, maximum, fallback) {
     return 'number' == typeof value && Number.isFinite(value) && value >= minimum && value <= maximum ? value : fallback;
 }
-export { DEFAULT_PROTECTION_HINT, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, SPREADSHEET_CONDITIONAL_ICON_SETS, applyPasswordlessEditableRanges, applySpreadsheetCellProtectionRanges, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetPaperSize, protectedSheetCount, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetProtectionKey, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withoutEditableRange };
+export { DEFAULT_PROTECTION_HINT, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, SPREADSHEET_CONDITIONAL_ICON_SETS, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, importedSheetProtectionAuthority, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetPaperSize, protectedSheetCount, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetProtectionKey, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withoutEditableRange };

package/dist/8715.js

@@ -1,4 +1,42 @@
 import { createOfficeId as createWorkId, directChild, attribute } from "./5184.js";
+function sparseArrayIndexes(values) {
+    if (!values) return [];
+    return Object.keys(values).flatMap((key)=>{
+        const index = Number(key);
+        return Number.isSafeInteger(index) && index >= 0 && index < values.length ? [
+            index
+        ] : [];
+    });
+}
+function sparseArrayEntries(values) {
+    if (!values) return [];
+    return sparseArrayIndexes(values).flatMap((index)=>{
+        const value = values[index];
+        return void 0 === value ? [] : [
+            [
+                index,
+                value
+            ]
+        ];
+    });
+}
+function sparseMatrixColumnCount(matrix) {
+    let maximum = 0;
+    for (const [, row] of sparseArrayEntries(matrix))maximum = Math.max(maximum, row.length);
+    return maximum;
+}
+function cloneSparseMatrix(source) {
+    const clone = [];
+    if (!source) return clone;
+    clone.length = source.length;
+    for (const [rowIndex, sourceRow] of sparseArrayEntries(source)){
+        const row = [];
+        row.length = sourceRow.length;
+        for (const columnIndex of sparseArrayIndexes(sourceRow))row[columnIndex] = sourceRow[columnIndex];
+        clone[rowIndex] = row;
+    }
+    return clone;
+}
 function normalizeWorkSpreadsheetDoughnutHoleSize(value) {
     const size = Number(value);
     if (!Number.isFinite(size)) return 50;
@@ -3725,8 +3763,8 @@ function spreadsheetFormulaRangeConflict(sheet, range) {
     if (!anchorCell) return '锚点单元格不存在';
     const overlaps = (sheet.formulaMetadata?.ranges ?? []).filter((candidate)=>candidate !== range && work_spreadsheet_formulas_rangesOverlap(bounds, parseSpreadsheetFormulaRange(candidate.reference)));
     if (overlaps.length) return '与其他公式范围重叠';
-    for (const [row, cells] of (sheet.data ?? []).entries())if (!(row < bounds.startRow) && !(row > bounds.endRow)) {
-        for (const [column, cell] of cells.entries())if (!(column < bounds.startColumn) && !(column > bounds.endColumn)) {
+    for (const [row, cells] of sparseArrayEntries(sheet.data))if (!(row < bounds.startRow) && !(row > bounds.endRow)) {
+        for (const [column, cell] of sparseArrayEntries(cells))if (!(column < bounds.startColumn) && !(column > bounds.endColumn)) {
             if (row !== anchor.row || column !== anchor.column) {
                 if (cell?.f) return `${spreadsheetCellAddress(row, column)} 包含独立公式`;
             }
@@ -3822,4 +3860,4 @@ function positiveNumber(value, fallback) {
 function transformFormulaOutsideStrings(formula, transform) {
     return formula.split(/("(?:[^"]|"")*")/).map((segment, index)=>index % 2 ? segment : transform(segment)).join('');
 }
-export { createSpreadsheetChartFromSelection, createSpreadsheetPivotFromSelection, defaultPivotValueCaption, defaultWorkSpreadsheetChartSeriesStyle, deleteSpreadsheetPivotTable, editableSpreadsheetFormula, effectiveSpreadsheetCalculationSettings, errorBarSourceValues, fitSpreadsheetTrendline, formatSpreadsheetCellRanges, formatSpreadsheetChartAxisNumber, formulaHasExternalReference, formulaHasStructuredReference, isValidSpreadsheetDefinedName, normalizeSpreadsheetPrintArea, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetBubbleSizeRepresents, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetChartColor, normalizeWorkSpreadsheetChartGapWidth, normalizeWorkSpreadsheetChartGrouping, normalizeWorkSpreadsheetChartLayout, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartLegendPosition, normalizeWorkSpreadsheetChartOverlap, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetChartSmoothLines, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetDataLabelPosition, normalizeWorkSpreadsheetDataLabels, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetScatterStyle, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetTrendlineType, parseSpreadsheetCellRanges, parseSpreadsheetChartReference, parseSpreadsheetPrintTitles, qualifySpreadsheetRange, readXlsxDrawingAnchor, reconcileSpreadsheetChartPreviews, reconcileSpreadsheetPivots, refreshSpreadsheetPivotTables, resolveSpreadsheetChart, roundChartNumber, spreadsheetCellAddress, spreadsheetChartAxisGridlinesVisible, spreadsheetChartAxisLabelLayout, spreadsheetChartAxisScale, spreadsheetChartAxisValueRatio, spreadsheetChartBarGeometry, spreadsheetChartCategoryLabelVisible, spreadsheetChartCategoryVisualIndex, spreadsheetChartCount, spreadsheetChartSeriesFillStyle, spreadsheetChartSeriesLayout, spreadsheetChartSeriesLegendColor, spreadsheetChartSeriesLineStyle, spreadsheetChartSeriesStyleContext, spreadsheetErrorBarAmounts, spreadsheetFormulaForXlsx, spreadsheetFormulaFunctions, spreadsheetFormulaRangeConflict, spreadsheetFormulaRangeForCell, spreadsheetFormulaRangesForSelection, spreadsheetPivotAggregationLabel, spreadsheetPivotCount, spreadsheetPivotFields, spreadsheetPivotFilterItems, spreadsheetPivotFilterValueKey, spreadsheetPivotIntersects, spreadsheetPivotOutputContains, spreadsheetPivotValidation, spreadsheetSheetsWithChartPreviews, stripSpreadsheetSheetQualifier, volatileSpreadsheetFormulaFunctions, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis, workSpreadsheetChartAxisLabelPositionLabel, workSpreadsheetChartAxisPositionLabel, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisTickMarkLabel, workSpreadsheetChartGroupingIsStacked, workSpreadsheetChartGroupingLabel, workSpreadsheetChartLegendPositionLabel, workSpreadsheetChartSupportsAxes, workSpreadsheetChartSupportsBarSpacing, workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, workSpreadsheetChartSupportsSeriesAnalysis, workSpreadsheetChartSupportsSmoothLines, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartTypeLabel, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetCombinationSeriesTypeLabel, workSpreadsheetDataLabelPositionLabel, workSpreadsheetErrorBarTypeLabel, workSpreadsheetErrorBarValueTypeLabel, workSpreadsheetTrendlineTypeLabel, xlsxDrawingAnchorToBounds, xlsxTwoCellAnchorMarkers };
+export { cloneSparseMatrix, createSpreadsheetChartFromSelection, createSpreadsheetPivotFromSelection, defaultPivotValueCaption, defaultWorkSpreadsheetChartSeriesStyle, deleteSpreadsheetPivotTable, editableSpreadsheetFormula, effectiveSpreadsheetCalculationSettings, errorBarSourceValues, fitSpreadsheetTrendline, formatSpreadsheetCellRanges, formatSpreadsheetChartAxisNumber, formulaHasExternalReference, formulaHasStructuredReference, isValidSpreadsheetDefinedName, normalizeSpreadsheetPrintArea, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetBubbleSizeRepresents, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetChartColor, normalizeWorkSpreadsheetChartGapWidth, normalizeWorkSpreadsheetChartGrouping, normalizeWorkSpreadsheetChartLayout, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartLegendPosition, normalizeWorkSpreadsheetChartOverlap, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetChartSmoothLines, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetDataLabelPosition, normalizeWorkSpreadsheetDataLabels, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetScatterStyle, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetTrendlineType, parseSpreadsheetCellRanges, parseSpreadsheetChartReference, parseSpreadsheetPrintTitles, qualifySpreadsheetRange, readXlsxDrawingAnchor, reconcileSpreadsheetChartPreviews, reconcileSpreadsheetPivots, refreshSpreadsheetPivotTables, resolveSpreadsheetChart, roundChartNumber, sparseArrayEntries, sparseArrayIndexes, sparseMatrixColumnCount, spreadsheetCellAddress, spreadsheetChartAxisGridlinesVisible, spreadsheetChartAxisLabelLayout, spreadsheetChartAxisScale, spreadsheetChartAxisValueRatio, spreadsheetChartBarGeometry, spreadsheetChartCategoryLabelVisible, spreadsheetChartCategoryVisualIndex, spreadsheetChartCount, spreadsheetChartSeriesFillStyle, spreadsheetChartSeriesLayout, spreadsheetChartSeriesLegendColor, spreadsheetChartSeriesLineStyle, spreadsheetChartSeriesStyleContext, spreadsheetErrorBarAmounts, spreadsheetFormulaForXlsx, spreadsheetFormulaFunctions, spreadsheetFormulaRangeConflict, spreadsheetFormulaRangeForCell, spreadsheetFormulaRangesForSelection, spreadsheetPivotAggregationLabel, spreadsheetPivotCount, spreadsheetPivotFields, spreadsheetPivotFilterItems, spreadsheetPivotFilterValueKey, spreadsheetPivotIntersects, spreadsheetPivotOutputContains, spreadsheetPivotValidation, spreadsheetSheetsWithChartPreviews, stripSpreadsheetSheetQualifier, volatileSpreadsheetFormulaFunctions, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis, workSpreadsheetChartAxisLabelPositionLabel, workSpreadsheetChartAxisPositionLabel, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisTickMarkLabel, workSpreadsheetChartGroupingIsStacked, workSpreadsheetChartGroupingLabel, workSpreadsheetChartLegendPositionLabel, workSpreadsheetChartSupportsAxes, workSpreadsheetChartSupportsBarSpacing, workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, workSpreadsheetChartSupportsSeriesAnalysis, workSpreadsheetChartSupportsSmoothLines, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartTypeLabel, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetCombinationSeriesTypeLabel, workSpreadsheetDataLabelPositionLabel, workSpreadsheetErrorBarTypeLabel, workSpreadsheetErrorBarValueTypeLabel, workSpreadsheetTrendlineTypeLabel, xlsxDrawingAnchorToBounds, xlsxTwoCellAnchorMarkers };

package/dist/9356.js

@@ -1,10 +1,128 @@
-async function materializeWorkFile(file) {
-    const bytes = await file.arrayBuffer();
-    return new File([
-        bytes
-    ], file.name, {
-        lastModified: file.lastModified,
-        type: file.type
+const stageRanges = {
+    reading: [
+        0,
+        0.2
+    ],
+    parsing: [
+        0.2,
+        0.75
+    ],
+    analyzing: [
+        0.75,
+        0.95
+    ],
+    finalizing: [
+        0.95,
+        1
+    ]
+};
+class WorkFileImportController {
+    options;
+    totalBytes;
+    progress = 0;
+    constructor(options, totalBytes){
+        this.options = options;
+        this.totalBytes = totalBytes;
+    }
+    get signal() {
+        return this.options.signal;
+    }
+    throwIfAborted() {
+        if (!this.signal?.aborted) return;
+        throw workFileImportAbortError(this.signal.reason);
+    }
+    report(stage, stageProgress, bytesRead = this.totalBytes) {
+        this.throwIfAborted();
+        const boundedStageProgress = Math.max(0, Math.min(1, stageProgress));
+        const [start, end] = stageRanges[stage];
+        this.progress = Math.max(this.progress, start + (end - start) * boundedStageProgress);
+        this.options.onProgress?.({
+            stage,
+            stageProgress: boundedStageProgress,
+            progress: this.progress,
+            bytesRead: Math.max(0, Math.min(this.totalBytes, bytesRead)),
+            totalBytes: this.totalBytes
+        });
+        this.throwIfAborted();
+    }
+    async checkpoint(stage, stageProgress) {
+        this.report(stage, stageProgress);
+        await this.yieldToMainThread();
+    }
+    async yieldToMainThread() {
+        this.throwIfAborted();
+        await new Promise((resolve)=>setTimeout(resolve, 0));
+        this.throwIfAborted();
+    }
+    complete() {
+        this.report('finalizing', 1);
+    }
+}
+function workFileImportAbortError(reason) {
+    if (reason instanceof Error && 'AbortError' === reason.name) return reason;
+    if ("u" > typeof DOMException) return new DOMException('Office file import was cancelled.', 'AbortError');
+    const error = new Error('Office file import was cancelled.');
+    error.name = 'AbortError';
+    return error;
+}
+const WORK_FILE_READ_CHUNK_BYTES = 4194304;
+async function materializeWorkFile(file, controller = new WorkFileImportController({}, file.size)) {
+    return (await materializeWorkFileSource(file, controller)).file;
+}
+async function materializeWorkFileSource(file, controller) {
+    const bytes = await readWorkFileBytes(file, controller);
+    return {
+        bytes,
+        file: new File([
+            bytes
+        ], file.name, {
+            lastModified: file.lastModified,
+            type: file.type
+        })
+    };
+}
+async function readWorkFileBytes(file, controller) {
+    controller.report('reading', 0, 0);
+    if (file.size <= WORK_FILE_READ_CHUNK_BYTES) {
+        const bytes = await abortableArrayBuffer(file.arrayBuffer(), controller);
+        controller.report('reading', 1, bytes.byteLength);
+        return bytes;
+    }
+    const bytes = new Uint8Array(file.size);
+    for(let offset = 0; offset < file.size; offset += WORK_FILE_READ_CHUNK_BYTES){
+        controller.throwIfAborted();
+        const end = Math.min(file.size, offset + WORK_FILE_READ_CHUNK_BYTES);
+        const chunk = await abortableArrayBuffer(file.slice(offset, end).arrayBuffer(), controller);
+        bytes.set(new Uint8Array(chunk), offset);
+        controller.report('reading', end / file.size, end);
+        if (end < file.size) await controller.yieldToMainThread();
+    }
+    return bytes.buffer;
+}
+async function abortableArrayBuffer(pending, controller) {
+    controller.throwIfAborted();
+    const signal = controller.signal;
+    if (!signal) return pending;
+    return new Promise((resolve, reject)=>{
+        const abort = ()=>{
+            cleanup();
+            try {
+                controller.throwIfAborted();
+            } catch (error) {
+                reject(error);
+            }
+        };
+        const cleanup = ()=>signal.removeEventListener('abort', abort);
+        signal.addEventListener('abort', abort, {
+            once: true
+        });
+        pending.then((bytes)=>{
+            cleanup();
+            resolve(bytes);
+        }, (error)=>{
+            cleanup();
+            reject(error);
+        });
     });
 }
-export { materializeWorkFile };
+export { WorkFileImportController, materializeWorkFile, materializeWorkFileSource };

package/dist/core.d.ts

@@ -21,6 +21,7 @@ export type { WorkEditorAgentRequest as EditorAgentRequest } from './internal/fe
 export type { WorkDocumentReviewConflict as DocumentReviewConflict, WorkDocumentReviewConflictEvent as DocumentReviewConflictEvent, WorkDocumentReviewConflictReason as DocumentReviewConflictReason, WorkDocumentReviewKind as DocumentReviewKind, } from './internal/features/work/work-document-review-conflicts';
 export type { WorkDocumentSelectionCommandFailure as DocumentSelectionCommandFailure, WorkDocumentSelectionCommandResult as DocumentSelectionCommandResult, WorkDocumentSelectionCommands as DocumentSelectionCommands, WorkDocumentSelectionContext as DocumentSelectionContext, WorkDocumentSelectionMenuIcon as DocumentSelectionMenuIcon, WorkDocumentSelectionMenuItem as DocumentSelectionMenuItem, WorkDocumentSelectionSnapshot as DocumentSelectionSnapshot, WorkGetDocumentSelectionMenuItems as GetDocumentSelectionMenuItems, } from './internal/features/work/work-document-selection-menu';
 export type { WorkArtifactExportOptions as ArtifactExportOptions } from './internal/features/work/work-file-io';
+export type { WorkFileImportOptions as OfficeFileImportOptions, WorkFileImportProgress as OfficeFileImportProgress, WorkFileImportStage as OfficeFileImportStage, } from './internal/features/work/work-file-import';
 export { createWorkArtifactBlob as createArtifactBlob, exportWorkArtifact as downloadArtifact, importWorkFile as importOfficeFile, WORK_IMPORT_ACCEPT as OFFICE_FILE_ACCEPT, workKindForFile as officeKindForFile, } from './internal/features/work/work-file-io';
 export { decodeWorkDocumentSnapshot as decodeDocumentSnapshot, encodeWorkDocumentSnapshot as encodeDocumentSnapshot, WORK_DOCUMENT_SNAPSHOT_MEDIA_TYPE as DOCUMENT_SNAPSHOT_MEDIA_TYPE, WORK_DOCUMENT_SNAPSHOT_SCHEMA as DOCUMENT_SNAPSHOT_SCHEMA, WORK_DOCUMENT_SNAPSHOT_VERSION as DOCUMENT_SNAPSHOT_VERSION, type WorkDocumentSnapshot as DocumentSnapshot, } from './internal/features/work/work-document-snapshot';
 export { applyWorkDocumentSource as applyDocumentSource, projectWorkDocumentSource as projectDocumentSource, WORK_DOCUMENT_SOURCE_MEDIA_TYPE as DOCUMENT_SOURCE_MEDIA_TYPE, WORK_DOCUMENT_SOURCE_SCHEMA as DOCUMENT_SOURCE_SCHEMA, WORK_DOCUMENT_SOURCE_VERSION as DOCUMENT_SOURCE_VERSION, type WorkDocumentSource as DocumentSource, } from './internal/features/work/work-document-source';

package/dist/internal/features/work/editors/spreadsheet-editor-support.d.ts

@@ -21,6 +21,7 @@ export declare function spreadsheetFontSizeOptions(current: number | undefined):
 export declare function spreadsheetFontFamilyOptions(current: string | undefined): OfficeSelectOption[];
 export declare function spreadsheetSheetsWithFiniteSelections(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
 export declare function spreadsheetSheetsForFortune(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
+export declare function spreadsheetSheetsFromFortune(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
 export declare function finiteSpreadsheetSelection(selection: Selection | undefined): Selection;
 export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets']): boolean;
 export declare function sameSpreadsheetHistoryContent(left: WorkSpreadsheetContent, right: WorkSpreadsheetContent): boolean;

package/dist/internal/features/work/editors/use-spreadsheet-collaboration.d.ts

@@ -8,7 +8,7 @@ export interface SpreadsheetCollaborationHistory {
     undo: () => boolean;
 }
 export interface SpreadsheetCollaborationViewController {
-    activateSheet: (sheetId: string) => void;
+    activateSheet: (sheetId: string) => boolean;
     select: (sheetId: string, selection: Selection) => void;
     setZoom: (sheetId: string, zoomRatio: number) => void;
 }
@@ -21,6 +21,7 @@ export declare function useSpreadsheetCollaboration({ initialContent, onChange,
     content: WorkSpreadsheetContent;
     history: SpreadsheetCollaborationHistory;
     onChange: (next: WorkSpreadsheetContent) => void;
+    onDerivedChange: (next: WorkSpreadsheetContent) => void;
     readOnly: boolean;
     view: SpreadsheetCollaborationViewController;
 };

package/dist/internal/features/work/spreadsheet-sparse.d.ts

@@ -0,0 +1,5 @@
+import type { CellMatrix } from '@fortune-sheet/core';
+export declare function sparseArrayIndexes(values: readonly unknown[] | undefined): number[];
+export declare function sparseArrayEntries<T>(values: readonly T[] | undefined): Array<[number, T]>;
+export declare function sparseMatrixColumnCount(matrix: CellMatrix | undefined): number;
+export declare function cloneSparseMatrix(source: CellMatrix | undefined): CellMatrix;

package/dist/internal/features/work/work-document-file-io.d.ts

@@ -1,4 +1,5 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
-export declare function importWorkDocumentFile(file: File, extension: string): Promise<WorkArtifact>;
+export declare function importWorkDocumentFile(file: File, extension: string, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function exportWorkDocumentArtifact(artifact: WorkArtifact): Promise<void>;
 export declare function createWorkDocumentBlob(artifact: WorkArtifact): Promise<Blob>;

package/dist/internal/features/work/work-docx-import.d.ts

@@ -21,6 +21,7 @@ import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-i
 import { type ImportedDocxTableCellMarkers } from './work-docx-table-cell-import';
 import { type ImportedDocxTableRowMarkers } from './work-docx-table-row-import';
 import { type ImportedDocxTableSizingMarkers } from './work-docx-table-sizing-import';
+import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkDocumentContent, WorkDocumentSectionLayout } from './work-types';
 type ImportedDocumentLayout = Omit<WorkDocumentContent, 'type' | 'html'>;
 export interface PreparedDocxImport {
@@ -56,7 +57,7 @@ export interface PreparedDocxImport {
     bibliography?: WorkDocumentContent['bibliography'];
     trackChanges: boolean;
 }
-export declare function prepareDocxImport(buffer: ArrayBuffer): Promise<PreparedDocxImport>;
+export declare function prepareDocxImport(buffer: ArrayBuffer, sourcePackage?: OoxmlPackage): Promise<PreparedDocxImport>;
 export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
 export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

package/dist/internal/features/work/work-file-data.d.ts

@@ -1 +1,7 @@
-export declare function materializeWorkFile(file: File): Promise<File>;
+import { WorkFileImportController } from './work-file-import';
+export interface MaterializedWorkFile {
+    bytes: ArrayBuffer;
+    file: File;
+}
+export declare function materializeWorkFile(file: File, controller?: WorkFileImportController): Promise<File>;
+export declare function materializeWorkFileSource(file: File, controller: WorkFileImportController): Promise<MaterializedWorkFile>;

package/dist/internal/features/work/work-file-import.d.ts

@@ -0,0 +1,28 @@
+export type WorkFileImportStage = 'reading' | 'parsing' | 'analyzing' | 'finalizing';
+export interface WorkFileImportProgress {
+    stage: WorkFileImportStage;
+    stageProgress: number;
+    progress: number;
+    bytesRead: number;
+    totalBytes: number;
+}
+export interface WorkFileImportOptions {
+    signal?: AbortSignal;
+    onProgress?: (progress: WorkFileImportProgress) => void;
+}
+export interface WorkFileImportContext {
+    bytes: ArrayBuffer;
+    controller: WorkFileImportController;
+}
+export declare class WorkFileImportController {
+    private readonly options;
+    readonly totalBytes: number;
+    private progress;
+    constructor(options: WorkFileImportOptions, totalBytes: number);
+    get signal(): AbortSignal | undefined;
+    throwIfAborted(): void;
+    report(stage: WorkFileImportStage, stageProgress: number, bytesRead?: number): void;
+    checkpoint(stage: WorkFileImportStage, stageProgress: number): Promise<void>;
+    yieldToMainThread(): Promise<void>;
+    complete(): void;
+}

package/dist/internal/features/work/work-file-io.d.ts

@@ -1,8 +1,9 @@
 export { WORK_IMPORT_ACCEPT } from './work-file-contract';
+import { type WorkFileImportOptions } from './work-file-import';
 import { type WorkPresentationExportOptions } from './work-presentation-file-io';
 import { type WorkArtifact, type WorkArtifactKind } from './work-types';
 export type WorkArtifactExportOptions = WorkPresentationExportOptions;
-export declare function importWorkFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkFile(file: File, options?: WorkFileImportOptions): Promise<WorkArtifact>;
 export declare function exportWorkArtifact(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<void>;
 export declare function createWorkArtifactBlob(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<Blob>;
 export declare function workKindForFile(file: File): WorkArtifactKind | null;

package/dist/internal/features/work/work-markdown-file-io.d.ts

@@ -1,3 +1,4 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
-export declare function importWorkMarkdownFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkMarkdownFile(file: File, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function createWorkMarkdownBlob(artifact: WorkArtifact): Blob;

package/dist/internal/features/work/work-office-diagnostics.d.ts

@@ -1,9 +1,10 @@
 import type { WorkBook } from 'xlsx';
+import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityReport } from './work-types';
 interface ConversionMessage {
     type: string;
     message: string;
 }
-export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[]): Promise<WorkCompatibilityReport>;
-export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook): Promise<WorkCompatibilityReport | null>;
+export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[], sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport>;
+export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook, sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport | null>;
 export {};

package/dist/internal/features/work/work-pptx-import.d.ts

@@ -3,4 +3,4 @@ export interface PptxImportResult {
     content: WorkPresentationContent;
     compatibility: WorkCompatibilityReport;
 }
-export declare function importPptxPresentation(file: File): Promise<PptxImportResult>;
+export declare function importPptxPresentation(file: File, sourceBytes?: ArrayBuffer): Promise<PptxImportResult>;

package/dist/internal/features/work/work-presentation-file-io.d.ts

@@ -1,3 +1,4 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
 type PptxConstructor = typeof import('pptxgenjs').default;
 declare global {
@@ -9,7 +10,7 @@ export interface WorkPresentationExportOptions {
     pptxRuntimeUrl?: string;
 }
 export declare const defaultPptxRuntimeUrl: string;
-export declare function importWorkPresentationFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkPresentationFile(file: File, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function exportWorkPresentationArtifact(artifact: WorkArtifact, options?: WorkPresentationExportOptions): Promise<void>;
 export declare function createWorkPresentationBlob(artifact: WorkArtifact, options?: WorkPresentationExportOptions): Promise<Blob>;
 export {};

package/dist/internal/features/work/work-spreadsheet-protection.d.ts

@@ -27,6 +27,7 @@ export interface FortuneSheetProtectionAuthority {
     hintText: string;
     defaultSheetHintText: string;
     allowRangeList: FortuneSheetEditableRange[];
+    cellProtectionRanges: SpreadsheetCellProtectionRange[];
     xlsxAttributes?: Record<string, string>;
 }
 export interface SpreadsheetCellProtectionRange {
@@ -37,6 +38,7 @@ export interface SpreadsheetCellProtectionRange {
 export declare function defaultSheetProtectionAuthority(enabled?: boolean): FortuneSheetProtectionAuthority;
 export declare function sheetProtectionAuthority(sheet: Sheet): FortuneSheetProtectionAuthority;
 export declare function normalizeSheetProtectionAuthority(source: unknown): FortuneSheetProtectionAuthority;
+export declare function importedSheetProtectionAuthority(authority: FortuneSheetProtectionAuthority | undefined, cellProtectionRanges: SpreadsheetCellProtectionRange[]): FortuneSheetProtectionAuthority | undefined;
 export declare function withSheetProtection(sheet: Sheet, enabled: boolean): Sheet;
 export declare function withSheetSelectionPermissions(sheet: Sheet, permissions: {
     selectLockedCells?: boolean;