@niicojs/excel 0.3.3 → 0.3.5

package/src/utils/format.ts

@@ -232,6 +232,8 @@ const formatDatePart = (value: Date, token: string, locale: string): string => {
       return padNumber(value.getMonth() + 1, 2);
     case 'm':
       return String(value.getMonth() + 1);
+    case 'dddd':
+      return value.toLocaleString(locale, { weekday: 'long' });
     case 'dd':
       return padNumber(value.getDate(), 2);
     case 'd':
@@ -285,7 +287,7 @@ const tokenizeDateFormat = (format: string): string[] => {
     }
 
     const lower = format.slice(i).toLowerCase();
-    const match = ['yyyy', 'yy', 'mmmm', 'mmm', 'mm', 'm', 'dd', 'd', 'hh', 'h', 'ss', 's'].find((t) =>
+    const match = ['yyyy', 'yy', 'mmmm', 'mmm', 'mm', 'm', 'dddd', 'dd', 'd', 'hh', 'h', 'ss', 's'].find((t) =>
       lower.startsWith(t),
     );
     if (match) {
@@ -324,22 +326,21 @@ const isDateFormat = (format: string): boolean => {
 };
 
 const formatDate = (value: Date, format: string, locale: string): string => {
+  if (locale === 'fr-FR' && format === '[$-F800]dddd\\,\\ mmmm\\ dd\\,\\ yyyy') {
+    format = 'dddd, dd mmmm yyyy';
+  }
   const tokens = tokenizeDateFormat(format);
   return tokens.map((token) => formatDatePart(value, token, locale)).join('');
 };
 
-export const formatCellValue = (
-  value: number | Date,
-  style: CellStyle | undefined,
-  locale?: string,
-): string | null => {
+export const formatCellValue = (value: number | Date, style: CellStyle | undefined, locale?: string): string | null => {
   const numberFormat = style?.numberFormat;
   if (!numberFormat) return null;
 
   const normalizedLocale = locale || DEFAULT_LOCALE;
   const sections = splitFormatSections(numberFormat);
   const hasNegativeSection = sections.length > 1;
-  const section = value instanceof Date ? sections[0] : value < 0 ? sections[1] ?? sections[0] : sections[0];
+  const section = value instanceof Date ? sections[0] : value < 0 ? (sections[1] ?? sections[0]) : sections[0];
 
   if (value instanceof Date && isDateFormat(section)) {
     return formatDate(value, section, normalizedLocale);

package/src/utils/xml.ts

@@ -22,7 +22,7 @@ const builderOptions = {
   commentPropName: '#comment',
   cdataPropName: '#cdata',
   format: false,
-  suppressEmptyNode: false,
+  suppressEmptyNode: true,
   suppressBooleanAttributes: false,
 };
 

package/src/utils/zip.ts

@@ -2,12 +2,155 @@ import { unzip, unzipSync, zip, zipSync, strFromU8, strToU8 } from 'fflate';
 
 export type ZipFiles = Map<string, Uint8Array>;
 
+export interface ZipStore {
+  get(path: string): Uint8Array | undefined;
+  set(path: string, content: Uint8Array): void;
+  has(path: string): boolean;
+  delete(path: string): void;
+  getText(path: string): string | undefined;
+  setText(path: string, content: string): void;
+  toFiles(): Promise<ZipFiles>;
+}
+
+class EagerZipStore implements ZipStore {
+  private _files: ZipFiles;
+
+  constructor(files: ZipFiles) {
+    this._files = files;
+  }
+
+  get(path: string): Uint8Array | undefined {
+    return this._files.get(path);
+  }
+
+  set(path: string, content: Uint8Array): void {
+    this._files.set(path, content);
+  }
+
+  has(path: string): boolean {
+    return this._files.has(path);
+  }
+
+  delete(path: string): void {
+    this._files.delete(path);
+  }
+
+  getText(path: string): string | undefined {
+    const data = this._files.get(path);
+    if (!data) return undefined;
+    return strFromU8(data);
+  }
+
+  setText(path: string, content: string): void {
+    this._files.set(path, strToU8(content));
+  }
+
+  toFiles(): Promise<ZipFiles> {
+    return Promise.resolve(this._files);
+  }
+}
+
+class LazyZipStore implements ZipStore {
+  private _data: Uint8Array;
+  private _files: ZipFiles = new Map();
+  private _deleted: Set<string> = new Set();
+  private _entryNames: Set<string> | null = null;
+
+  constructor(data: Uint8Array) {
+    this._data = data;
+  }
+
+  get(path: string): Uint8Array | undefined {
+    if (this._deleted.has(path)) return undefined;
+    const cached = this._files.get(path);
+    if (cached) return cached;
+
+    this._ensureIndex();
+    if (this._entryNames && !this._entryNames.has(path)) return undefined;
+
+    const result = unzipSync(this._data, {
+      filter: (file) => file.name === path,
+    });
+    const data = result[path];
+    if (data) {
+      this._files.set(path, data);
+    }
+    return data;
+  }
+
+  set(path: string, content: Uint8Array): void {
+    this._files.set(path, content);
+    this._deleted.delete(path);
+    if (this._entryNames) {
+      this._entryNames.add(path);
+    }
+  }
+
+  has(path: string): boolean {
+    if (this._deleted.has(path)) return false;
+    if (this._files.has(path)) return true;
+    this._ensureIndex();
+    return this._entryNames?.has(path) ?? false;
+  }
+
+  delete(path: string): void {
+    this._files.delete(path);
+    this._deleted.add(path);
+    if (this._entryNames) {
+      this._entryNames.delete(path);
+    }
+  }
+
+  getText(path: string): string | undefined {
+    const data = this.get(path);
+    if (!data) return undefined;
+    return strFromU8(data);
+  }
+
+  setText(path: string, content: string): void {
+    this.set(path, strToU8(content));
+  }
+
+  async toFiles(): Promise<ZipFiles> {
+    const unzipped = unzipSync(this._data);
+    const files = new Map<string, Uint8Array>(Object.entries(unzipped));
+    for (const path of this._deleted) {
+      files.delete(path);
+    }
+    for (const [path, content] of this._files) {
+      files.set(path, content);
+    }
+    return files;
+  }
+
+  private _ensureIndex(): void {
+    if (this._entryNames) return;
+    const names = new Set<string>();
+    unzipSync(this._data, {
+      filter: (file) => {
+        names.add(file.name);
+        return false;
+      },
+    });
+    this._entryNames = names;
+  }
+}
+
+export const createZipStore = (): ZipStore => {
+  return new EagerZipStore(new Map());
+};
+
 /**
  * Reads a ZIP file and returns a map of path -> content
  * @param data - ZIP file as Uint8Array
  * @returns Promise resolving to a map of file paths to contents
  */
-export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
+export const readZip = (data: Uint8Array, options?: { lazy?: boolean }): Promise<ZipStore> => {
+  const lazy = options?.lazy ?? false;
+  if (lazy) {
+    return Promise.resolve(new LazyZipStore(data));
+  }
+
   const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined';
   if (isBun) {
     try {
@@ -16,7 +159,7 @@ export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
       for (const [path, content] of Object.entries(result)) {
         files.set(path, content);
       }
-      return Promise.resolve(files);
+      return Promise.resolve(new EagerZipStore(files));
     } catch (error) {
       return Promise.reject(error);
     }
@@ -32,7 +175,7 @@ export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
       for (const [path, content] of Object.entries(result)) {
         files.set(path, content);
       }
-      resolve(files);
+      resolve(new EagerZipStore(files));
     });
   });
 };
@@ -42,9 +185,10 @@ export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
  * @param files - Map of file paths to contents
  * @returns Promise resolving to ZIP file as Uint8Array
  */
-export const writeZip = (files: ZipFiles): Promise<Uint8Array> => {
+export const writeZip = async (files: ZipStore): Promise<Uint8Array> => {
+  const resolved = await files.toFiles();
   const zipData: Record<string, Uint8Array> = {};
-  for (const [path, content] of files) {
+  for (const [path, content] of resolved) {
     zipData[path] = content;
   }
 
@@ -71,15 +215,13 @@ export const writeZip = (files: ZipFiles): Promise<Uint8Array> => {
 /**
  * Reads a file from the ZIP as a UTF-8 string
  */
-export const readZipText = (files: ZipFiles, path: string): string | undefined => {
-  const data = files.get(path);
-  if (!data) return undefined;
-  return strFromU8(data);
+export const readZipText = (files: ZipStore, path: string): string | undefined => {
+  return files.getText(path);
 };
 
 /**
  * Writes a UTF-8 string to the ZIP files map
  */
-export const writeZipText = (files: ZipFiles, path: string, content: string): void => {
-  files.set(path, strToU8(content));
+export const writeZipText = (files: ZipStore, path: string, content: string): void => {
+  files.setText(path, content);
 };