web-csv-toolbox 0.0.0-next-20240116142901 → 0.0.0-next-20240116161004

package/dist/web-csv-toolbox.js

@@ -1,576 +0,0 @@
-const FieldDelimiter = Symbol.for("web-csv-toolbox.FieldDelimiter");
-const RecordDelimiter = Symbol.for("web-csv-toolbox.RecordDelimiter");
-const Field = Symbol.for("web-csv-toolbox.Field");
-
-const CR = "\r";
-const CRLF = "\r\n";
-const LF = "\n";
-const COMMA = ",";
-const DOUBLE_QUOTE = '"';
-
-function assertCommonOptions(options) {
-  if (typeof options.quotation === "string" && options.quotation.length === 0) {
-    throw new Error("quotation must not be empty");
-  }
-  if (typeof options.delimiter === "string" && options.delimiter.length === 0) {
-    throw new Error("delimiter must not be empty");
-  }
-  if (options.quotation.includes(LF) || options.quotation.includes(CR)) {
-    throw new Error("quotation must not include CR or LF");
-  }
-  if (options.delimiter.includes(LF) || options.delimiter.includes(CR)) {
-    throw new Error("delimiter must not include CR or LF");
-  }
-  if (options.delimiter.includes(options.quotation) || options.quotation.includes(options.delimiter)) {
-    throw new Error(
-      "delimiter and quotation must not include each other as a substring"
-    );
-  }
-}
-
-function escapeRegExp(v) {
-  return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-class Lexer {
-  #delimiter;
-  #delimiterLength;
-  #quotation;
-  #quotationLength;
-  #matcher;
-  #buffer = "";
-  #flush = false;
-  constructor({
-    delimiter = COMMA,
-    quotation = DOUBLE_QUOTE
-  } = {}) {
-    assertCommonOptions({ delimiter, quotation });
-    this.#delimiter = delimiter;
-    this.#delimiterLength = delimiter.length;
-    this.#quotation = quotation;
-    this.#quotationLength = quotation.length;
-    const d = escapeRegExp(delimiter);
-    const q = escapeRegExp(quotation);
-    this.#matcher = new RegExp(
-      `^(?:(?!${q})(?!${d})(?![\\r\\n]))([\\S\\s\\uFEFF\\xA0]+?)(?=${q}|${d}|\\r|\\n|$)`
-    );
-  }
-  lex(chunk, buffering = false) {
-    if (!buffering) {
-      this.#flush = true;
-    }
-    if (typeof chunk === "string" && chunk.length !== 0) {
-      this.#buffer += chunk;
-    }
-    return this.#tokens();
-  }
-  flush() {
-    this.#flush = true;
-    return [...this.#tokens()];
-  }
-  *#tokens() {
-    if (this.#flush) {
-      if (this.#buffer.endsWith(CRLF)) {
-        this.#buffer = this.#buffer.slice(0, -CRLF.length);
-      } else if (this.#buffer.endsWith(LF)) {
-        this.#buffer = this.#buffer.slice(0, -LF.length);
-      }
-    }
-    let currentField = null;
-    for (let token; token = this.#nextToken(); ) {
-      switch (token) {
-        case FieldDelimiter:
-          if (currentField) {
-            yield currentField;
-            currentField = null;
-          }
-          yield token;
-          break;
-        case RecordDelimiter:
-          if (currentField) {
-            yield currentField;
-            currentField = null;
-          }
-          yield token;
-          break;
-        default:
-          if (currentField) {
-            currentField.value += token.value;
-          } else {
-            currentField = token;
-          }
-          break;
-      }
-    }
-    if (currentField) {
-      yield currentField;
-    }
-  }
-  #nextToken() {
-    if (this.#buffer.length === 0) {
-      return null;
-    }
-    if (this.#flush === false && (this.#buffer === CRLF || this.#buffer === LF)) {
-      return null;
-    }
-    if (this.#buffer.startsWith(CRLF)) {
-      this.#buffer = this.#buffer.slice(2);
-      return RecordDelimiter;
-    }
-    if (this.#buffer.startsWith(LF)) {
-      this.#buffer = this.#buffer.slice(1);
-      return RecordDelimiter;
-    }
-    if (this.#buffer.startsWith(this.#delimiter)) {
-      this.#buffer = this.#buffer.slice(this.#delimiterLength);
-      return FieldDelimiter;
-    }
-    if (this.#buffer.startsWith(this.#quotation)) {
-      if (this.#flush === false && this.#buffer.endsWith(this.#quotation)) {
-        return null;
-      }
-      return this.#extractQuotedString();
-    }
-    const match = this.#matcher.exec(this.#buffer);
-    if (match) {
-      if (this.#flush === false && match[0].length === this.#buffer.length) {
-        return null;
-      }
-      this.#buffer = this.#buffer.slice(match[0].length);
-      return { type: Field, value: match[0] };
-    }
-    return null;
-  }
-  #extractQuotedString() {
-    let end = this.#quotationLength;
-    let value = "";
-    while (end < this.#buffer.length) {
-      if (this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation && this.#buffer.slice(
-        end + this.#quotationLength,
-        end + this.#quotationLength * 2
-      ) === this.#quotation) {
-        value += this.#quotation;
-        end += this.#quotationLength * 2;
-        continue;
-      }
-      if (this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation) {
-        if (this.#flush === false && end + this.#quotationLength < this.#buffer.length && this.#buffer.slice(
-          end + this.#quotationLength,
-          this.#delimiterLength
-        ) !== this.#delimiter && this.#buffer.slice(
-          end + this.#quotationLength,
-          end + this.#quotationLength + 2
-        ) !== CRLF && this.#buffer.slice(
-          end + this.#quotationLength,
-          end + this.#quotationLength + 1
-        ) !== LF) {
-          return null;
-        }
-        this.#buffer = this.#buffer.slice(end + this.#quotationLength);
-        return { type: Field, value };
-      }
-      value += this.#buffer[end];
-      end++;
-    }
-    return null;
-  }
-}
-
-class LexerTransformer extends TransformStream {
-  constructor(options = {}) {
-    const lexer = new Lexer(options);
-    super({
-      transform: (chunk, controller) => {
-        if (chunk.length !== 0) {
-          controller.enqueue([...lexer.lex(chunk, true)]);
-        }
-      },
-      flush: (controller) => {
-        controller.enqueue(lexer.flush());
-      }
-    });
-  }
-}
-
-class RecordAssembler {
-  #fieldIndex = 0;
-  #row = [];
-  #header;
-  #dirty = false;
-  constructor(options = {}) {
-    if (options.header !== void 0 && Array.isArray(options.header)) {
-      this.#setHeader(options.header);
-    }
-  }
-  *assemble(tokens, flush = true) {
-    for (const token of tokens) {
-      switch (token) {
-        case FieldDelimiter:
-          this.#fieldIndex++;
-          this.#dirty = true;
-          break;
-        case RecordDelimiter:
-          if (this.#header === void 0) {
-            this.#setHeader(this.#row);
-          } else {
-            if (this.#dirty) {
-              yield Object.fromEntries(
-                this.#header.map((header, index) => [
-                  header,
-                  this.#row.at(index)
-                ])
-              );
-            } else {
-              yield Object.fromEntries(
-                this.#header.map((header) => [header, ""])
-              );
-            }
-          }
-          this.#fieldIndex = 0;
-          this.#row = new Array(this.#header?.length).fill("");
-          this.#dirty = false;
-          break;
-        default:
-          this.#dirty = true;
-          this.#row[this.#fieldIndex] = token.value;
-          break;
-      }
-    }
-    if (flush) {
-      yield* this.flush();
-    }
-  }
-  *flush() {
-    if (this.#header !== void 0) {
-      if (this.#dirty) {
-        yield Object.fromEntries(
-          this.#header.filter((v) => v).map((header, index) => [header, this.#row.at(index)])
-        );
-      }
-    }
-  }
-  #setHeader(header) {
-    this.#header = header;
-    if (this.#header.length === 0) {
-      throw new Error("The header must not be empty.");
-    }
-    if (new Set(this.#header).size !== this.#header.length) {
-      throw new Error("The header must not contain duplicate fields.");
-    }
-  }
-}
-
-class RecordAssemblerTransformer extends TransformStream {
-  constructor(options = {}) {
-    const assembler = new RecordAssembler(options);
-    super({
-      transform: (tokens, controller) => {
-        for (const token of assembler.assemble(tokens, false)) {
-          controller.enqueue(token);
-        }
-      },
-      flush: (controller) => {
-        for (const token of assembler.flush()) {
-          controller.enqueue(token);
-        }
-      }
-    });
-  }
-}
-
-function parseStringToArraySync(csv, options) {
-  const lexer = new Lexer(options);
-  const assembler = new RecordAssembler(options);
-  const tokens = lexer.lex(csv);
-  return [...assembler.assemble(tokens)];
-}
-
-function parseStringToIterableIterator(csv, options) {
-  const lexer = new Lexer(options);
-  const assembler = new RecordAssembler(options);
-  const tokens = lexer.lex(csv);
-  return assembler.assemble(tokens);
-}
-
-function parseStringToStream(csv, options) {
-  const lexer = new Lexer(options);
-  const assembler = new RecordAssembler(options);
-  return new ReadableStream({
-    start(controller) {
-      const tokens = lexer.lex(csv);
-      for (const record of assembler.assemble(tokens)) {
-        controller.enqueue(record);
-      }
-      controller.close();
-    }
-  });
-}
-
-async function toArray(...args) {
-  const rows = [];
-  for await (const row of this(...args)) {
-    rows.push(row);
-  }
-  return rows;
-}
-
-async function* parseString(csv, options) {
-  yield* parseStringToIterableIterator(csv, options);
-}
-((parseString2) => {
-  Object.defineProperty(parseString2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-  Object.defineProperty(parseString2, "toArraySync", {
-    enumerable: true,
-    writable: false,
-    value: parseStringToArraySync
-  });
-  Object.defineProperty(parseString2, "toIterableIterator", {
-    enumerable: true,
-    writable: false,
-    value: parseStringToIterableIterator
-  });
-  Object.defineProperty(parseString2, "toStream", {
-    enumerable: true,
-    writable: false,
-    value: parseStringToStream
-  });
-})(parseString || (parseString = {}));
-
-function convertBinaryToString(binary, options) {
-  return new TextDecoder(options?.charset, {
-    ignoreBOM: options?.ignoreBOM,
-    fatal: options?.fatal
-  }).decode(binary instanceof ArrayBuffer ? new Uint8Array(binary) : binary);
-}
-
-function parseBinaryToArraySync(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToArraySync(csv, options);
-}
-
-function parseBinaryToIterableIterator(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToIterableIterator(csv, options);
-}
-
-function parseBinaryToStream(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToStream(csv, options);
-}
-
-function iterableIteratorToAsync(iterator) {
-  return {
-    async next() {
-      const result = iterator.next();
-      return Promise.resolve(result);
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    }
-  };
-}
-
-function parseBinary(bytes, options) {
-  const iterator = parseBinaryToIterableIterator(bytes, options);
-  return iterableIteratorToAsync(iterator);
-}
-((parseBinary2) => {
-  Object.defineProperty(parseBinary2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-  Object.defineProperty(parseBinary2, "toArraySync", {
-    enumerable: true,
-    writable: false,
-    value: parseBinaryToArraySync
-  });
-  Object.defineProperty(parseBinary2, "toIterableIterator", {
-    enumerable: true,
-    writable: false,
-    value: parseBinaryToIterableIterator
-  });
-  Object.defineProperty(parseBinary2, "toStream", {
-    enumerable: true,
-    writable: false,
-    value: parseBinaryToStream
-  });
-})(parseBinary || (parseBinary = {}));
-
-function pipeline(stream, ...transformers) {
-  return new ReadableStream({
-    start: (controller) => {
-      (() => transformers.reduce(
-        (stream2, transformer) => stream2.pipeThrough(transformer),
-        stream
-      ).pipeTo(
-        new WritableStream({
-          write: (v) => controller.enqueue(v),
-          close: () => controller.close()
-        })
-      ))();
-    }
-  });
-}
-
-function parseUint8ArrayStreamToStream(stream, options) {
-  const { charset, fatal, ignoreBOM, decomposition } = options ?? {};
-  return decomposition ? pipeline(
-    stream,
-    new DecompressionStream(decomposition),
-    new TextDecoderStream(charset, { fatal, ignoreBOM }),
-    new LexerTransformer(options),
-    new RecordAssemblerTransformer(options)
-  ) : pipeline(
-    stream,
-    new TextDecoderStream(charset, { fatal, ignoreBOM }),
-    new LexerTransformer(options),
-    new RecordAssemblerTransformer(options)
-  );
-}
-
-async function* streamToAsyncIterableIterator(stream) {
-  const reader = stream.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    yield value;
-  }
-}
-
-function parseUint8ArrayStream(stream, options) {
-  const recordStream = parseUint8ArrayStreamToStream(stream, options);
-  return streamToAsyncIterableIterator(recordStream);
-}
-((parseUint8ArrayStream2) => {
-  Object.defineProperty(parseUint8ArrayStream2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-  Object.defineProperty(parseUint8ArrayStream2, "toStream", {
-    enumerable: true,
-    writable: false,
-    value: parseUint8ArrayStreamToStream
-  });
-})(parseUint8ArrayStream || (parseUint8ArrayStream = {}));
-
-function parseStringStreamToStream(stream, options) {
-  return pipeline(
-    stream,
-    new LexerTransformer(options),
-    new RecordAssemblerTransformer(options)
-  );
-}
-
-function parseStringStream(stream, options) {
-  const recordStream = parseStringStreamToStream(stream, options);
-  return streamToAsyncIterableIterator(recordStream);
-}
-((parseStringStream2) => {
-  Object.defineProperty(parseStringStream2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-  Object.defineProperty(parseStringStream2, "toStream", {
-    enumerable: true,
-    writable: false,
-    value: parseStringStreamToStream
-  });
-})(parseStringStream || (parseStringStream = {}));
-
-function parseMime(contentType) {
-  const [type, ...parameters] = contentType.split(";");
-  const result = {
-    type: type.trim(),
-    parameters: {}
-  };
-  for (const paramator of parameters) {
-    const [key, value] = paramator.split("=");
-    result.parameters[key.trim()] = value.trim();
-  }
-  return result;
-}
-
-function getOptionsFromResponse(response, options = {}) {
-  const { headers } = response;
-  const contentType = headers.get("content-type") ?? "text/csv";
-  const mime = parseMime(contentType);
-  if (mime.type !== "text/csv") {
-    throw new Error(`Invalid mime type: ${contentType}`);
-  }
-  const decomposition = headers.get("content-encoding") ?? void 0;
-  const charset = mime.parameters.charset ?? "utf-8";
-  return {
-    decomposition,
-    charset,
-    ...options
-  };
-}
-
-function parseResponseToStream(response, options) {
-  const options_ = getOptionsFromResponse(response, options);
-  if (response.body === null) {
-    throw new Error("Response body is null");
-  }
-  return parseUint8ArrayStreamToStream(response.body, options_);
-}
-
-function parseResponse(response, options) {
-  const options_ = getOptionsFromResponse(response, options);
-  if (response.body === null) {
-    throw new Error("Response body is null");
-  }
-  return parseUint8ArrayStream(response.body, options_);
-}
-((parseResponse2) => {
-  Object.defineProperty(parseResponse2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-  Object.defineProperty(parseResponse2, "toStream", {
-    enumerable: true,
-    writable: false,
-    value: parseResponseToStream
-  });
-})(parseResponse || (parseResponse = {}));
-
-async function* parse(csv, options) {
-  if (typeof csv === "string") {
-    yield* parseString(csv, options);
-  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {
-    yield* parseBinary(csv, options);
-  } else if (csv instanceof ReadableStream) {
-    const [branch1, branch2] = csv.tee();
-    const reader1 = branch1.getReader();
-    const { value: firstChunk } = await reader1.read();
-    reader1.releaseLock();
-    if (typeof firstChunk === "string") {
-      yield* parseStringStream(branch2, options);
-    } else if (firstChunk instanceof Uint8Array) {
-      yield* parseUint8ArrayStream(
-        branch2,
-        options
-      );
-    }
-  } else if (csv instanceof Response) {
-    yield* parseResponse(csv, options);
-  }
-}
-((parse2) => {
-  Object.defineProperty(parse2, "toArray", {
-    enumerable: true,
-    writable: false,
-    value: toArray
-  });
-})(parse || (parse = {}));
-
-export { Field, FieldDelimiter, LexerTransformer, RecordAssemblerTransformer, RecordDelimiter, parse, parseBinary, parseResponse, parseString, parseStringStream, parseUint8ArrayStream };
-//# sourceMappingURL=web-csv-toolbox.js.map