1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.// Implements the CSV spec at https://tools.ietf.org/html/rfc4180
// This module is browser compatible.
const QUOTE = '"';export const NEWLINE = "\r\n";
export class StringifyError extends Error {  readonly name = "StringifyError";}
function getEscapedString(value: unknown, sep: string): string {  if (value === undefined || value === null) return "";  let str = "";
  if (typeof value === "object") str = JSON.stringify(value);  else str = String(value);
  // Is regex.test more performant here? If so, how to dynamically create?  // https://stackoverflow.com/questions/3561493/  if (str.includes(sep) || str.includes(NEWLINE) || str.includes(QUOTE)) {    return `${QUOTE}${str.replaceAll(QUOTE, `${QUOTE}${QUOTE}`)}${QUOTE}`;  }
  return str;}
type PropertyAccessor = number | string;
/** * @param fn Optional callback for transforming the value * * @param header Explicit column header name. If omitted, * the (final) property accessor is used for this value. * * @param prop Property accessor(s) used to access the value on the object */export type ColumnDetails = {  // "unknown" is more type-safe, but inconvenient for user. How to resolve?  // deno-lint-ignore no-explicit-any  fn?: (value: any) => string | Promise<string>;  header?: string;  prop: PropertyAccessor | PropertyAccessor[];};
export type Column = ColumnDetails | PropertyAccessor | PropertyAccessor[];
type NormalizedColumn = Omit<ColumnDetails, "header" | "prop"> & {  header: string;  prop: PropertyAccessor[];};
function normalizeColumn(column: Column): NormalizedColumn {  let fn: NormalizedColumn["fn"],    header: NormalizedColumn["header"],    prop: NormalizedColumn["prop"];
  if (typeof column === "object") {    if (Array.isArray(column)) {      header = String(column[column.length - 1]);      prop = column;    } else {      ({ fn } = column);      prop = Array.isArray(column.prop) ? column.prop : [column.prop];      header = typeof column.header === "string"        ? column.header        : String(prop[prop.length - 1]);    }  } else {    header = String(column);    prop = [column];  }
  return { fn, header, prop };}
type ObjectWithStringPropertyKeys = Record<string, unknown>;
/** An object (plain or array) */export type DataItem = ObjectWithStringPropertyKeys | unknown[];
/** * Returns an array of values from an object using the property accessors * (and optional transform function) in each column */async function getValuesFromItem(  item: DataItem,  normalizedColumns: NormalizedColumn[],): Promise<unknown[]> {  const values: unknown[] = [];
  for (const column of normalizedColumns) {    let value: unknown = item;
    for (const prop of column.prop) {      if (typeof value !== "object" || value === null) continue;      if (Array.isArray(value)) {        if (typeof prop === "number") value = value[prop];        else {          throw new StringifyError('Property accessor is not of type "number"');        }      } // I think this assertion is safe. Confirm?      else value = (value as ObjectWithStringPropertyKeys)[prop];    }
    if (typeof column.fn === "function") value = await column.fn(value);    values.push(value);  }
  return values;}
/** * @param headers Whether or not to include the row of headers. * Default: `true` * * @param separator Delimiter used to separate values. Examples: *  - `","` _comma_ (Default) *  - `"\t"` _tab_ *  - `"|"` _pipe_ *  - etc. */export type StringifyOptions = {  headers?: boolean;  separator?: string;};
/** * @param data The array of objects to encode * @param columns Array of values specifying which data to include in the output * @param options Output formatting options */export async function stringify(  data: DataItem[],  columns: Column[],  options: StringifyOptions = {},): Promise<string> {  const { headers, separator: sep } = {    headers: true,    separator: ",",    ...options,  };  if (sep.includes(QUOTE) || sep.includes(NEWLINE)) {    const message = [      "Separator cannot include the following strings:",      '  - U+0022: Quotation mark (")',      "  - U+000D U+000A: Carriage Return + Line Feed (\\r\\n)",    ].join("\n");    throw new StringifyError(message);  }
  const normalizedColumns = columns.map(normalizeColumn);  let output = "";
  if (headers) {    output += normalizedColumns      .map((column) => getEscapedString(column.header, sep))      .join(sep);    output += NEWLINE;  }
  for (const item of data) {    const values = await getValuesFromItem(item, normalizedColumns);    output += values      .map((value) => getEscapedString(value, sep))      .join(sep);    output += NEWLINE;  }
  return output;}