@syzlm/ofdparser 0.0.1

package/src/lib/load-files.ts

@@ -0,0 +1,26 @@
+import JSZip from 'jszip';
+import UnzipError from '../errors/UnzipErrors';
+
+type TypeFile = File | ArrayBuffer;
+
+const unzipFile = (file: TypeFile) => {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!file) {
+        reject(new UnzipError(404));
+      }
+      if (file instanceof File) {
+      }
+      if (file instanceof ArrayBuffer) {
+        JSZip.loadAsync(file).then(res => {
+          console.log(res);
+        });
+      }
+      resolve('');
+    } catch (err) {
+      console.error('unzip:', err);
+    }
+  });
+};
+
+export default unzipFile;

package/src/lib/load-opentype.ts

@@ -0,0 +1,161 @@
+// import { parse, Font } from 'opentype.js';
+
+import loadScript from './load-script';
+
+/**
+ * @description 加载内置字体
+ */
+class FontMap {
+  loading: boolean = false;
+
+  baseLocation: URL | null = null;
+
+  fontFile: {
+    [k: string | number]: {
+      getPath: (
+        s: string,
+        n?: number,
+        c?: number,
+        v?: number,
+        op?: { hinting?: boolean; kerning?: boolean; features?: boolean },
+      ) => { glyphs: any; toSVG: (a: number) => string; Path: any };
+    };
+  } = {};
+
+  intervalTimer: NodeJS.Timer | null = null;
+  callbacks: {
+    funs: (l: boolean) => void;
+    k: string | number;
+    file: ArrayBuffer;
+  }[] = [];
+
+  constructor() {
+    this.getBaseUrl();
+  }
+
+  init() {
+    if (!window.opentype) {
+      this.loading = true;
+      // const baseUrl = this.getBaseUrl();
+      if (this.baseLocation) {
+        loadScript(this.baseLocation.href + 'opentype.js')
+          .then(() => {
+            this.loading = false;
+          })
+          .catch(() => {
+            // 加载js失败，尝试加载外网
+            // cdn方式引入opentype.js
+            loadScript('/libs/opentype.min.js')
+              .then(() => {
+                this.loading = false;
+              })
+              .catch(() => {
+                this.loading = false;
+                // 加载js失败，尝试加载本地js
+                console.warn('加载字体渲染文件失败');
+                //
+              });
+            //
+          });
+      } else {
+        loadScript('/libs/opentype.min.js')
+          .then(() => {
+            this.loading = false;
+          })
+          .catch(() => {
+            this.loading = false;
+            // 加载js失败，尝试加载本地js
+            console.warn('加载字体渲染文件失败');
+            //
+          });
+      }
+    } else {
+      // callback && callback();
+    }
+  }
+
+  getBaseUrl() {
+    if (typeof document !== 'undefined' && document.currentScript) {
+      // @ts-ignore
+      this.baseLocation = new URL('./', document.currentScript.src || '');
+    } else {
+      // 动态查找js
+      const scripts = Array.from(document.getElementsByTagName('script'));
+      const currentScript = scripts.find(script => {
+        const src = script.getAttribute('src');
+        // 根据实际情况调整匹配条件
+        return src && src.includes('load-opentype');
+      });
+
+      if (currentScript) {
+        const src = currentScript.getAttribute('src');
+        this.baseLocation = new URL('./', src || window.location.href);
+      } else {
+        // 降级方案：使用最后一个 script 标签
+        const lastScript = scripts[scripts.length - 1];
+        const src = lastScript?.getAttribute('src');
+        this.baseLocation = src ? new URL('./', src) : null;
+      }
+      this.baseLocation = null;
+
+      console.warn('获取地址失败！');
+    }
+  }
+
+  setFontFile(key: string | number, file: ArrayBuffer, callback: (r: boolean) => void) {
+    if (!window.opentype) {
+      if (this.loading) {
+        // 等待 opentype.min.js 加载完成
+        if (!this.intervalTimer) {
+          this.intervalTimer = setInterval(() => {
+            if (!this.loading) {
+              if (this.intervalTimer) {
+                clearInterval(this.intervalTimer);
+              }
+              if (this.callbacks.length) {
+                this.callbacks.forEach(({ k, funs, file: f }) => {
+                  try {
+                    if (!this.fontFile[k]) {
+                      this.fontFile[k] = window.opentype.parse(f);
+                    }
+                    funs(true);
+                  } catch (er) {
+                    console.warn(er);
+                    funs(false);
+                  }
+                });
+              }
+            }
+          }, 30);
+        }
+        this.callbacks.push({ k: key, file, funs: callback });
+      } else {
+        this.init();
+      }
+      return;
+    }
+    try {
+      if (window.opentype && !this.fontFile[key]) {
+        this.fontFile[key] = window.opentype.parse(file);
+      }
+      callback(true);
+    } catch (err) {
+      console.warn(err);
+      callback(false);
+    }
+  }
+
+  getFontFile(key: string | number, txt: string, x: number, y: number, s: number): string {
+    return this.fontFile[key].getPath(txt, x, y, s, { hinting: true }).toSVG(2);
+  }
+
+  destroy() {
+    this.fontFile = {};
+    this.callbacks = [];
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+    }
+  }
+}
+
+export default new FontMap();

package/src/lib/load-script.ts

@@ -0,0 +1,33 @@
+export default function loadScript(url: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    try {
+      const script = document.createElement('script') as HTMLScriptElement & {
+        readState: string;
+        onreadystatechange: null | (() => void);
+      };
+      script.type = 'text/javascript';
+      if (script.readState) {
+        script.onreadystatechange = () => {
+          if (
+            script.readState === 'loaded' ||
+            script.readState === 'complete'
+          ) {
+            script.onreadystatechange = null;
+            resolve(true);
+          }
+        };
+        return;
+      }
+      script.onload = () => {
+        resolve(true);
+      };
+      script.onerror = err => {
+        reject(err);
+      };
+      script.setAttribute('src', url);
+      document.head.appendChild(script);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}

package/src/lib/mime.ts

@@ -0,0 +1,97 @@
+import VaildMimeError from '../errors/MimeError';
+import readBuffer from './read-buffer';
+
+const mimeTypes: { [key: string]: string } = {
+  '504B0304': 'zip',
+  '504B0506': 'zip',
+  '504B0708': 'zip',
+  '52617221': 'rar',
+
+  '89504E47': 'png',
+  '25504446': 'pdf',
+  '4F676753': 'ogg',
+  '75737461': 'tar',
+  D0CF11E0: 'msOffice',
+  FFD8FFDB: 'jpg',
+  FFD8FFE0: 'jpg',
+  FFD8FFEE: 'jpeg',
+  FFD8FFE1: 'jpeg',
+  '47494638': 'gif',
+  '52494646': 'wegp',
+  '424D663B': 'bmp',
+  '3C3F786D': 'xml',
+  '3C786272': 'xml',
+  '32303232': 'xml'
+};
+
+const msOfficeType: { [key: string]: string } = {
+  'application/msword': 'doc',
+  'pplication/vnd.ms-excel': 'xls',
+  'pplication/vnd.mspowerpoint': 'ppt',
+  'pplication/vnd.ms-outlook': 'msg'
+};
+
+const zipsFileType: { [key: string]: string } = {
+  'application/ofd': 'ofd',
+  'application/vnd.ofd': 'ofd',
+  'application/docx': 'docx',
+  'application/xlsx': 'xlsx',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+    'docx',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+    'pptx',
+  'application/zip': 'zip',
+  'application/x-zip-ompressed': 'zip'
+};
+
+/**
+ * 使用arrayBuffer获取文件Magic，转换为文件类型
+ * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+ * @link https://datatracker.ietf.org/doc/html/rfc6838
+ * @date 2022/7/5 - 09:48:27
+ */
+const getFileType = async (file: File): Promise<string> => {
+  try {
+    if (!file || !(file instanceof File)) {
+      throw new VaildMimeError(404);
+    }
+    const bufferData = await readBuffer(file);
+    // uint8Array 转16进制
+    const hex16Array = Array.prototype.map.call(new Uint8Array(bufferData), x =>
+      ('00' + x.toString(16)).slice(-2)
+    );
+
+    const hex16String = hex16Array.join('').toLocaleUpperCase();
+
+    const mimeType = mimeTypes[hex16String];
+    let { type: fileType } = file;
+    if (!fileType && !mimeType) {
+      return '';
+    }
+
+    // 同时存在 fileType 以及 mimeType 优先使用mimeType，zip mimeType需要判断，fileType是否是zip类型文件比如：PDF
+    if (fileType && mimeType) {
+      if (mimeType === 'zip') {
+        return zipsFileType[fileType] || fileType.replace(/application\//, '');
+      }
+      if (mimeType === 'msOffice') {
+        return msOfficeType[fileType] || fileType.replace(/application\//, '');
+      }
+      return mimeType;
+    }
+    if (!fileType) {
+      // 不存在type,截取文件名后缀
+      return mimeType;
+    }
+    if (!mimeType) {
+      return fileType;
+    }
+  } catch (err) {
+    console.error(err, 'getFileType error');
+  }
+
+  return '';
+};
+
+export default getFileType;

package/src/lib/read-buffer.ts

@@ -0,0 +1,19 @@
+import VaildMimeError from '../errors/MimeError';
+
+const readBuffer = (file: File, start = 0, end = 4): Promise<ArrayBuffer> =>
+  new Promise((resolve, reject) => {
+    try {
+      const readFile = new FileReader();
+      readFile.onload = () => {
+        if (readFile.result && readFile.result instanceof ArrayBuffer) {
+          resolve(readFile.result);
+        }
+      };
+      readFile.onerror = reject;
+      readFile.readAsArrayBuffer(file.slice(start, end));
+    } catch (err) {
+      reject(new VaildMimeError(500));
+    }
+  });
+
+export default readBuffer;

package/src/lib/toFixeds.ts

@@ -0,0 +1,56 @@
+/**
+ * 精确小数(目标小数位数小于最大精确位数直接返回原值，否则在精确位数+1上四舍五入)
+ * @param {Number} num 待精确小数
+ * @param {Number} min 最小位数
+ * @param {Number} max 最大位数
+ */
+export const toFixeds = (num: number | string, min?: number, max?: number): string => {
+  const minFix = min || 2;
+  const maxFix = max;
+  let str = String(num).replace(/^-/, '');
+  if (maxFix && maxFix < minFix) {
+    return `${num}`;
+  }
+  const prefixSymbol = String(num).startsWith('-') ? '-' : '';
+  const dotIndex = str.indexOf('.');
+  if (dotIndex === -1) {
+    let dotArr = '.';
+    for (let i = 0; i < minFix; i++) {
+      dotArr += '0';
+    }
+    return str + dotArr;
+  }
+  const maxLen = maxFix || minFix;
+  let i = dotIndex + 1;
+  let n = '';
+  while (n.length < maxLen) {
+    n += (str[i++] || '0') + '';
+    if (!str[i] && n.length >= minFix) {
+      break;
+    }
+  }
+
+  const newStr = str.substring(0, dotIndex) + '.' + n;
+  let step = 0; //四舍五入进位
+  if (i < str.length) {
+    step = Number(str[i]) >= 5 ? 1 : 0;
+  }
+  const nums = newStr.split('');
+  const numberNums = nums.map(item => (item === '.' ? '.' : Number(item)));
+  if (step > 0) {
+    while (i > 0) {
+      i--;
+      if (numberNums[i] === '.') {
+        continue;
+      }
+      const sum = Number(numberNums[i]) + Number(step);
+      numberNums[i] = sum % 10;
+      step = sum >= 10 ? 1 : 0;
+      if (i === 0 && Number(numberNums[i]) === 0) {
+        numberNums.splice(0, 0, 1);
+      }
+      if (step === 0) break;
+    }
+  }
+  return `${prefixSymbol}` + numberNums.join('');
+};

package/src/ofd/ConverterDpi.ts

@@ -0,0 +1,35 @@
+import UnitCoversion from '../lib/UnitCoversion';
+
+class ConverterDpi {
+  /**
+   * 缩放比例
+   * @date 2022/8/23 - 09:26:37
+   *
+   * @type {number}
+   */
+  scale: number;
+
+  initScale: number;
+  constructor() {
+    this.scale = 1;
+    this.initScale = 1;
+  }
+  setInitScale(n: number) {
+    this.initScale = n || 1;
+  }
+  setScale(n: number, isSeal = false) {
+    if (!n) {
+      return;
+    }
+    if (isSeal) {
+      this.scale = n * this.initScale;
+    } else {
+      this.scale = n;
+    }
+  }
+  getScreenPX(millimeter: string | number) {
+    return UnitCoversion.CoversionPx(Number(millimeter) * (this.scale || 1));
+  }
+}
+
+export default new ConverterDpi();

package/src/ofd/OFD.md

@@ -0,0 +1,38 @@
+# OFD 文档结构说明
+
+## ofd.xml
+
+### ofd.xml 文件主入口属性说明
+
+| 名称       | 类型       | 说明                                                                                | 备注 |
+| ---------- | ---------- | ----------------------------------------------------------------------------------- | ---- |
+| Version    | xs:string  | 文件格式版本号，取值为 1.0                                                          | 必填 |
+| DocType    | xs:string  | 文件格式子集类型，取值为“OFD”表明此文档符合标准，取值为“OFD-A”表明符合 OFD 存档规范 |
+| DocBody    |            | 文件对象入口，可以存在多个。以便在一个文档中存在多个版式文档                        | 必选 |
+| DocInfo    | CT_DocInfo | 文档元数据信息描述，文档元数据信息描述如[文档元数据属性描述](#文档元数据属性描述)   | 必选 |
+| DocRoot    | ST_Loc     | 指向文档根节点文档，                                                                | 可选 |
+| Versions   |            | 包含多个版本描述节点，用于定义文件因注释或修改产生的版本信息                        | 可选 |
+| Singnature | ST_Loc     | 指向给文档中签名和签章结构                                                          | 可选 |
+
+### 文档元数据属性描述
+
+| 名称           | 类型      | 说明                                                                                                         | 备注 |
+| -------------- | --------- | ------------------------------------------------------------------------------------------------------------ | ---- |
+| DocID          | xs:string | 采用 UUID 算法生成的由 32 位字符组成文件标识，每个 DocId 在文档创建或生产的时候分配                          | 可选 |
+| Title          | xs:string | 文档标题，标题可与文件名不同                                                                                 | 可选 |
+| Author         | xs:string | 文档作者                                                                                                     | 可选 |
+| Subject        | xs:string | 文档主题                                                                                                     | 可选 |
+| Abstract       | xs:string | 文档摘要和注释                                                                                               | 可选 |
+| CreationDate   | xs:string | 文档创建日期                                                                                                 | 可选 |
+| ModDate        | xs:string | 文档最近修改日期                                                                                             | 可选 |
+| DocUsage       | xs:string | 文档分类，可取值（Normal—普通电子文档（default）；Ebook—电子书；ENewsPaper—电子报纸；EMagzine—电子期刊杂志） | 可选 |
+| Cover          | ST_Loc    | 文档封面，此路径指向一个图片文件                                                                             | 可选 |
+| keywords       |           | 关键词集合，每一个关键词用一个 Keyword 子节点表示                                                            | 可选 |
+| Keyword        | xs:string | 关键词                                                                                                       | 必选 |
+| Creator        | xs:string | 创建文档应用程序                                                                                             | 可选 |
+| CreatorVersion | xs:string | 创建文档应用程序版本                                                                                         | 可选 |
+| CustomDatas    |           | 用户自定义元数据集合，其子节点为 CustomData                                                                  | 可选 |
+| CustomData     | xs:string | 用户自定义元数据，可以指定一个名称和对应的值                                                                 | 必选 |
+| Name           | xs:string | 用户自定义元数据名称                                                                                         | 必选 |
+
+### 文档根节点

package/src/ofd/TODO.md

@@ -0,0 +1,10 @@
+# 第一步 解析 OFD.xml
+# 第二部 解析 DocumnetRes.xml
+# 第三部 解析 Documnet.xml
+# 第四步 解析 Annotations.xml
+# 第五步 解析 Annotation.xml
+
+# 将 xml 文件转换成平级数组，方便获取 text 内容
+
+# 区分 Document Page Signs DocumentRes Annotation Attachs Content_0
+

package/src/ofd/index.ts

@@ -0,0 +1 @@
+export { default, getSVGDoms } from './ofd';