hwpkit-dev 0.0.1 → 0.0.2

package/hwp-analyze.ts

@@ -0,0 +1,90 @@
+import * as fs from 'fs';
+import pako from 'pako';
+
+const hwp = fs.readFileSync('/mnt/92b2cb7e-8f06-4e4f-bfde-a14c87f2f96c/Github/hwpkit/data/sample/sample1_input.hwp');
+const SS = 512;
+const buf = hwp.buffer.slice(hwp.byteOffset, hwp.byteOffset + hwp.length);
+
+function u32LE(b: Buffer, off: number) {
+  return b[off] | (b[off+1]<<8) | (b[off+2]<<16) | ((b[off+3]&0xFF)*0x1000000);
+}
+function i32LE(b: Buffer, off: number) {
+  const v = u32LE(b,off);
+  return v >= 0x80000000 ? v - 0x100000000 : v;
+}
+function u16LE(b: Buffer, off: number) { return b[off] | (b[off+1]<<8); }
+
+const hdr = hwp.slice(0, 512);
+const fatSec = u32LE(hdr as Buffer, 76);
+const dirSec = u32LE(hdr as Buffer, 48);
+
+function sectorSlice(sec: number) {
+  const off = (sec+1)*SS;
+  return hwp.slice(off, off+SS) as Buffer;
+}
+
+const fatSector = sectorSlice(fatSec);
+function nextSec(sec: number) { return u32LE(fatSector as Buffer, (sec%128)*4); }
+
+function readChain(startSec: number, maxB = 200000): Buffer {
+  const chunks: Buffer[] = [];
+  let sec = startSec, tot = 0;
+  while (sec < 0xFFFFFFFE && tot < maxB) {
+    chunks.push(sectorSlice(sec) as Buffer);
+    tot += SS;
+    sec = nextSec(sec);
+  }
+  return Buffer.concat(chunks);
+}
+
+const dirBuf = readChain(dirSec, 2048);
+function readEntry(idx: number) {
+  const base = idx*128;
+  const nl = u16LE(dirBuf, base+64);
+  let name = '';
+  for (let i=0;i<(nl/2)-1&&i<32;i++) name += String.fromCharCode(u16LE(dirBuf, base+i*2));
+  return {
+    name, type: dirBuf[base+66],
+    child: i32LE(dirBuf, base+76), right: i32LE(dirBuf, base+72),
+    startSec: u32LE(dirBuf, base+116), size: u32LE(dirBuf, base+120)
+  };
+}
+
+let docInfoE: any = null, sec0E: any = null;
+function walk(idx: number, depth = 0) {
+  if (idx < 0 || idx > 100) return;
+  const e = readEntry(idx);
+  if (depth < 5) console.log(' '.repeat(depth*2) + idx + ': "' + e.name + '" type=' + e.type + ' sz=' + e.size);
+  if (e.name === 'DocInfo') docInfoE = e;
+  if (e.name === 'Section0') sec0E = e;
+  walk(e.child, depth+1);
+  walk(e.right, depth);
+}
+walk(0);
+
+if (!docInfoE || !sec0E) { console.log('NOT FOUND'); process.exit(1); }
+
+const diC = readChain(docInfoE.startSec, docInfoE.size+512);
+const s0C = readChain(sec0E.startSec, sec0E.size+512);
+const diRaw = Buffer.from(pako.inflate(diC.slice(0,docInfoE.size)));
+const s0Raw = Buffer.from(pako.inflate(s0C.slice(0,sec0E.size)));
+
+function parseRecs(buf: Buffer) {
+  const recs: any[] = []; let off = 0;
+  while (off+4 <= buf.length) {
+    const h = u32LE(buf,off), tag=h&0x3FF, lv=(h>>10)&0x3FF;
+    let sz=(h>>>20)&0xFFF, hSz=4;
+    if(sz===0xFFF){sz=u32LE(buf,off+4);hSz=8;}
+    if(off+hSz+sz>buf.length) break;
+    recs.push({tag,lv,sz,data:buf.slice(off+hSz,off+hSz+sz)});
+    off+=hSz+sz;
+  }
+  return recs;
+}
+
+const s0 = parseRecs(s0Raw);
+console.log('\nSection0 records:', s0.length);
+for (const r of s0.slice(0, 50)) {
+  const h = r.data.slice(0,Math.min(r.sz,50)).toString('hex');
+  console.log(`tag=${r.tag} lv=${r.lv} sz=${r.sz} [${h}]`);
+}

package/inspect-doc.ts

@@ -0,0 +1,57 @@
+import { Pipeline, TreeWalker, countNodes } from './src/index';
+import * as fs from 'fs';
+
+async function inspectDoc(filePath: string, description: string) {
+  console.log(`\n📄 ${description}`);
+  console.log(`   File: ${filePath} (${fs.statSync(filePath).size} bytes)`);
+
+  const data = fs.readFileSync(filePath);
+  const pipeline = Pipeline.open(data);
+  const result = await pipeline.inspect();
+
+  if (!result.ok) {
+    console.error(`   ❌ FAILED: ${result.error}`);
+    return;
+  }
+
+  const doc = result.data;
+  console.log(`   Meta: title="${doc.meta.title}", author="${doc.meta.author}"`);
+  console.log(`   Sheets: ${doc.kids.length}`);
+
+  const walker = new TreeWalker();
+  let paraCount = 0, spanCount = 0, txtCount = 0, imgCount = 0, gridCount = 0;
+  let totalChars = 0;
+
+  walker.walk(doc, (node) => {
+    switch (node.tag) {
+      case 'para': paraCount++; break;
+      case 'span': spanCount++; break;
+      case 'txt': txtCount++; totalChars += node.content.length; break;
+      case 'img': imgCount++; break;
+      case 'grid': gridCount++; break;
+    }
+  });
+
+  console.log(`   Paragraphs: ${paraCount}`);
+  console.log(`   Spans: ${spanCount}`);
+  console.log(`   Text nodes: ${txtCount}, Total chars: ${totalChars}`);
+  console.log(`   Images: ${imgCount}`);
+  console.log(`   Tables (grids): ${gridCount}`);
+
+  if (result.warns.length > 0) {
+    console.log(`   ⚠️  Warnings: ${result.warns.slice(0, 5).join(', ')}${result.warns.length > 5 ? '...' : ''}`);
+  }
+}
+
+async function main() {
+  // Input files
+  await inspectDoc('./data/sample/sample1_input.hwp', 'Sample1 Input (HWP)');
+  await inspectDoc('./data/sample/sample3_input.hwpx', 'Sample3 Input (HWPX)');
+  await inspectDoc('./data/sample/sample4_input.docx', 'Sample4 Input (DOCX)');
+
+  // Expected outputs
+  await inspectDoc('./data/sample/sample1_output.docx', 'Sample1 Expected Output (DOCX)');
+  await inspectDoc('./data/sample/sample1_output.hwpx', 'Sample1 Expected Output (HWPX)');
+}
+
+main().catch(console.error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hwpkit-dev",
   "description": "HWP/HWPX/DOCX/MD 양방향 문서 변환 라이브러리",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": {
     "name": "INMD1",
     "email": "lyw514549@gmail.com",
@@ -31,7 +31,9 @@
     "playground": "vite --config playground/vite.config.ts"
   },
   "dependencies": {
+    "fs": "^0.0.1-security",
     "pako": "^2.1.0",
+    "path": "^0.12.7",
     "saxes": "^6.0.0"
   },
   "devDependencies": {

package/src/decoders/docx/DocxDecoder.ts

@@ -18,6 +18,7 @@ import type {
   CellProps,
   GridProps,
   TableLook,
+  Stroke,
   ImgLayout,
   ImgHorzAlign,
   ImgVertAlign,
@@ -90,6 +91,17 @@ export class DocxDecoder implements Decoder {
         }
       }
 
+      // Parse styles.xml for tblStyle defaults
+      let stylesMap: StylesMap = new Map();
+      const stylesXml = files.get("word/styles.xml");
+      if (stylesXml) {
+        try {
+          stylesMap = await parseStylesMap(TextKit.decode(stylesXml));
+        } catch {
+          /* non-fatal */
+        }
+      }
+
       const docStr = TextKit.decode(docXml);
       const docObj: any = await XmlKit.parseStrict(docStr);
 
@@ -97,7 +109,7 @@ export class DocxDecoder implements Decoder {
       const dims = extractDims(body) ?? { ...A4 };
       const elements = getBodyElements(body);
 
-      const decCtx: DecCtx = { relsMap, files, shield, numMap, warns };
+      const decCtx: DecCtx = { relsMap, files, shield, numMap, warns, stylesMap };
 
       const kids: ContentNode[] = [];
       for (const el of elements) {
@@ -153,12 +165,30 @@ export class DocxDecoder implements Decoder {
 
 // ─── types ─────────────────────────────────────────────────
 
+interface TblBorderDef {
+  top?: Stroke;
+  bottom?: Stroke;
+  left?: Stroke;
+  right?: Stroke;
+  insideH?: Stroke;
+  insideV?: Stroke;
+}
+
+/** Parsed tblStyle defaults from styles.xml */
+interface TblStyleDef {
+  tblBorders?: TblBorderDef;
+  cellBg?: string; // default cell background
+}
+
+type StylesMap = Map<string, TblStyleDef>; // styleId → defaults
+
 interface DecCtx {
   relsMap: Map<string, string>;
   files: Map<string, Uint8Array>;
   shield: ShieldedParser;
   numMap: NumMap;
   warns: string[];
+  stylesMap: StylesMap;
 }
 
 // numId → { abstractNumId, levels: Map<ilvl, { fmt, isOrdered }> }
@@ -679,6 +709,85 @@ function decodeRun(run: any, ctx: DecCtx): SpanNode {
   return buildSpan(content, props);
 }
 
+/** Parse all 6 border sides from a w:tblBorders or w:tcBorders node */
+function parseBorderDef(bdrNode: any): TblBorderDef {
+  const sides: [string, keyof TblBorderDef][] = [
+    ["top", "top"], ["bottom", "bottom"], ["left", "left"], ["right", "right"],
+    ["insideH", "insideH"], ["insideV", "insideV"],
+  ];
+  const result: TblBorderDef = {};
+  for (const [xml, prop] of sides) {
+    const bdr = bdrNode?.["w:" + xml]?.[0]?._attr ?? bdrNode?.[xml]?.[0]?._attr;
+    if (!bdr) continue;
+    const val = bdr?.["w:val"] ?? bdr?.val;
+    if (val === "none" || val === "nil") continue; // explicit none → skip (no border)
+    result[prop] = safeStrokeDocx(
+      val,
+      Number(bdr?.["w:sz"] ?? bdr?.sz ?? 4),
+      bdr?.["w:color"] ?? bdr?.color,
+    );
+  }
+  return result;
+}
+
+/** Parse styles.xml and build a map of tblStyle defaults */
+async function parseStylesMap(xml: string): Promise<StylesMap> {
+  const map: StylesMap = new Map();
+  try {
+    const obj: any = await XmlKit.parseStrict(xml);
+    const stylesRoot = obj?.["w:styles"]?.[0] ?? obj?.styles?.[0] ?? obj;
+    const styleArr = toArr(stylesRoot?.["w:style"] ?? stylesRoot?.style);
+    for (const style of styleArr) {
+      const attr = style?._attr ?? {};
+      const type = attr?.["w:type"] ?? attr?.type;
+      if (type !== "table") continue;
+      const id = attr?.["w:styleId"] ?? attr?.styleId;
+      if (!id) continue;
+      const tblPr = style?.["w:tblPr"]?.[0] ?? style?.tblPr?.[0];
+      const tblBdrNode = tblPr?.["w:tblBorders"]?.[0] ?? tblPr?.tblBorders?.[0];
+      const tblBorders = tblBdrNode ? parseBorderDef(tblBdrNode) : undefined;
+      // tcStyle > tcBdr for default cell borders
+      const tcStyle = style?.["w:tcStyle"]?.[0] ?? style?.tcStyle?.[0];
+      const tcBdrNode = tcStyle?.["w:tcBdr"]?.[0] ?? tcStyle?.tcBdr?.[0];
+      if (tcBdrNode) {
+        const cellDef = parseBorderDef(tcBdrNode);
+        // merge into tblBorders as inner/outer defaults
+        if (!tblBorders) {
+          map.set(id, { tblBorders: cellDef });
+        } else {
+          map.set(id, { tblBorders: { ...cellDef, ...tblBorders } });
+        }
+      } else if (tblBorders) {
+        map.set(id, { tblBorders });
+      }
+    }
+  } catch {
+    /* non-fatal */
+  }
+  return map;
+}
+
+/** Resolve final CellProps borders using 3-level priority chain */
+function resolveCellBorders(
+  cp: CellProps,
+  ri: number, ci: number, rs: number, cs: number,
+  rowCount: number, colCount: number,
+  tblBdr: TblBorderDef,
+): CellProps {
+  const isTopEdge    = ri === 0;
+  const isBottomEdge = ri + rs >= rowCount;
+  const isLeftEdge   = ci === 0;
+  const isRightEdge  = ci + cs >= colCount;
+
+  // Apply tblBorders only where no explicit tcBorder was set
+  const resolved: CellProps = { ...cp };
+  if (!resolved.top)   resolved.top   = isTopEdge    ? tblBdr.top    : tblBdr.insideH;
+  if (!resolved.bot)   resolved.bot   = isBottomEdge ? tblBdr.bottom : tblBdr.insideH;
+  if (!resolved.left)  resolved.left  = isLeftEdge   ? tblBdr.left   : tblBdr.insideV;
+  if (!resolved.right) resolved.right = isRightEdge  ? tblBdr.right  : tblBdr.insideV;
+  return resolved;
+}
+
 function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
   // Parse tblPr for table styles
   const tblPr = tbl?.["w:tblPr"]?.[0] ?? tbl?.tblPr?.[0] ?? {};
@@ -700,21 +809,20 @@ function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
     bandedCols: tblLookAttr?.["w:noVBand"] === "0" || undefined,
   };
 
-  // Parse table borders for defaultStroke
-  const tblBorders = tblPr?.["w:tblBorders"]?.[0] ?? tblPr?.tblBorders?.[0];
-  let defaultStroke = undefined;
-  if (tblBorders) {
-    const top =
-      tblBorders?.["w:top"]?.[0]?._attr ?? tblBorders?.top?.[0]?._attr;
-    if (top) {
-      defaultStroke = safeStrokeDocx(
-        top?.["w:val"] ?? top?.val,
-        Number(top?.["w:sz"] ?? top?.sz ?? 4),
-        top?.["w:color"] ?? top?.color,
-      );
-    }
+  // ① tblStyle 기본값 로드
+  const tblStyleId = (tblPr?.["w:tblStyle"]?.[0]?._attr ?? tblPr?.tblStyle?.[0]?._attr)?.["w:val"];
+  const styleDef = tblStyleId ? ctx.stylesMap.get(tblStyleId) : undefined;
+  let tblBdr: TblBorderDef = styleDef?.tblBorders ?? {};
+
+  // ② tblBorders 재정의 (tblStyle보다 우선)
+  const tblBordersNode = tblPr?.["w:tblBorders"]?.[0] ?? tblPr?.tblBorders?.[0];
+  if (tblBordersNode) {
+    const parsed = parseBorderDef(tblBordersNode);
+    tblBdr = { ...tblBdr, ...parsed };
   }
 
+  // defaultStroke for HWPX/HWP encoders: use insideH (inner horizontal border)
+  const defaultStroke = tblBdr.insideH ?? tblBdr.top;
   const gridProps: GridProps = { look, defaultStroke };
 
   // Read column widths from w:tblGrid
@@ -790,6 +898,14 @@ function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
       trPr?.["w:tblHeader"]?.[0] != null || trPr?.tblHeader?.[0] != null;
     if (ri === 0 && isHeaderRow) gridProps.headerRow = true;
 
+    // Row height from w:trHeight
+    let rowHeightPt: number | undefined;
+    const trHAttr = trPr?.["w:trHeight"]?.[0]?._attr ?? trPr?.trHeight?.[0]?._attr;
+    if (trHAttr) {
+      const hDxa = Number(trHAttr?.["w:val"] ?? trHAttr?.val ?? 0);
+      if (hDxa > 0) rowHeightPt = Metric.dxaToPt(hDxa);
+    }
+
     const cellNodes: CellNode[] = [];
     for (let ci = 0; ci < rawRow.length; ci++) {
       const rc = rawRow[ci];
@@ -803,24 +919,25 @@ function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
       const bgAttr = tcPr?.["w:shd"]?.[0]?._attr ?? {};
       const bg = safeHex(bgAttr?.["w:fill"] ?? bgAttr?.fill);
 
-      // Cell borders
-      const tcBorders = tcPr?.["w:tcBorders"]?.[0] ?? tcPr?.tcBorders?.[0];
+      // ③ tcBorders 셀 수준 재정의 (우선순위 가장 높음)
+      const tcBordersNode = tcPr?.["w:tcBorders"]?.[0] ?? tcPr?.tcBorders?.[0];
       const cp: CellProps = { bg, isHeader: isHeaderRow || undefined };
 
-      if (tcBorders) {
+      if (tcBordersNode) {
         const dirs: Array<[string, "top" | "bot" | "left" | "right"]> = [
-          ["top", "top"],
-          ["bottom", "bot"],
-          ["left", "left"],
-          ["right", "right"],
+          ["top", "top"], ["bottom", "bot"], ["left", "left"], ["right", "right"],
         ];
         for (const [xmlTag, propKey] of dirs) {
           const bdr =
-            tcBorders?.["w:" + xmlTag]?.[0]?._attr ??
-            tcBorders?.[xmlTag]?.[0]?._attr;
-          if (bdr) {
+            tcBordersNode?.["w:" + xmlTag]?.[0]?._attr ??
+            tcBordersNode?.[xmlTag]?.[0]?._attr;
+          if (!bdr) continue;
+          const val = bdr?.["w:val"] ?? bdr?.val;
+          if (val === "none" || val === "nil") {
+            // explicit none: keep as undefined (no border)
+          } else {
             cp[propKey] = safeStrokeDocx(
-              bdr?.["w:val"] ?? bdr?.val,
+              val,
               Number(bdr?.["w:sz"] ?? bdr?.sz ?? 4),
               bdr?.["w:color"] ?? bdr?.color,
             );
@@ -834,15 +951,23 @@ function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
       const vaVal = vaAttr?.["w:val"] ?? vaAttr?.val;
       if (vaVal) {
         const vaMap: Record<string, "top" | "mid" | "bot"> = {
-          top: "top",
-          center: "mid",
-          bottom: "bot",
+          top: "top", center: "mid", bottom: "bot",
         };
         cp.va = vaMap[vaVal];
       }
 
       const rs = rsMap.get(`${ri},${ci}`) ?? 1;
 
+      // Compute logical column index for this cell
+      let gridColIdx = 0;
+      for (let prevCi = 0; prevCi < ci; prevCi++) {
+        if (!rawRow[prevCi].vMergeContinue) gridColIdx += rawRow[prevCi].gridSpan;
+      }
+
+      // Apply 3-level border resolution (tblStyle → tblBorders → tcBorders already in cp)
+      const colCount = gridProps.colWidths?.length ?? rawGrid[0]?.reduce((s, c) => s + c.gridSpan, 0) ?? 1;
+      const resolvedCp = resolveCellBorders(cp, ri, gridColIdx, rs, rc.gridSpan, rawGrid.length, colCount, tblBdr);
+
       const paras = toArr(cell?.["w:p"] ?? cell?.p).map((p: any) =>
         decodePara(p, ctx),
       );
@@ -850,11 +975,11 @@ function decodeGrid(tbl: any, ctx: DecCtx): GridNode {
         buildCell(paras.length > 0 ? paras : [buildPara([buildSpan("")])], {
           cs: rc.gridSpan,
           rs,
-          props: cp,
+          props: resolvedCp,
         }),
       );
     }
-    return buildRow(cellNodes);
+    return buildRow(cellNodes, rowHeightPt);
   });
   return buildGrid(rowNodes, gridProps);
 }