29 | import DotObject from 'dot-object';
30 |
31 | function Interface_ (name='', params={}) {
32 | class I_ {
33 | constructor (n, p) {
34 | this.name = `dottie.${n}`;
35 | this.params = p;
36 | }
37 |
38 | get req() {
39 | throw Error(`Missing at least one required parameter for ${this.name}: ${Object.keys(this.params)}`);
40 | }
41 |
42 | extra(kwargs) {
43 | if (Object.entries(kwargs).length > 0)
44 | throw Error(`Extra parameters passed to ${this.name}: ${Object.entries(kwargs)}`);
45 | }
46 |
47 | typecheck(args) {
48 | // arguments is an object-like array, need to flatten it so that we represent it as viewed from function scope
49 | let argObj = {};
50 | for (const prop in args) {
51 | argObj = {...argObj, ...args[prop]};
52 | }
53 |
54 | // now that both have matching types, let's go
55 | for (const prop in this.params) {
56 | if (this.params[prop] === 'any') continue; // type of 'any' special meaning is to skip it
57 | if (argObj[prop] === undefined) continue;
58 | if (this.params[prop] === 'array') {
59 | if (!Array.isArray(argObj[prop])) throw new Error(`Type mismatch in ${this.name}: "${prop}". Expected array but got ${typeof(argObj)} instead`);
60 | } else if (typeof(argObj[prop]) !== this.params[prop]) {
61 | throw new Error(`Type mismatch in ${this.name}: "${prop}". Expected ${this.params[prop]} but got ${typeof(argObj[prop])} instead`);
62 | }
63 | }
64 | }
65 | }
66 | return new I_(name, params);
67 | }
68 |
69 |
70 | // create interfaces that allows us to enforce type checks
71 | const MoveI = Interface_('move', {sourcePath: 'string', destPath: 'string', obj: 'object'});
72 | const CopyI = Interface_('copy', {obj: 'object', sourcePath: 'string', target: 'object', destPath: 'string'});
73 | const TransferI = Interface_('transfer', {sourcePath: 'string', destPath: 'string', obj: 'object', target: 'object'});
74 | const ExpandI = Interface_('expand', {obj: 'object'});
75 | const GetI = Interface_('get', {path: 'string', obj: 'object'});
76 | const SetI = Interface_('set', {path: 'string', obj: 'object', value: 'any'});
77 | const DeleteI = Interface_('delete', {path: 'string', obj: 'object'});
78 | const RemoveI = Interface_('remove', {path: 'string', obj: 'object'});
79 | const TransformI = Interface_('transform', {recipe: 'object', obj: 'object'});
80 | const DotI = Interface_('dot', {obj: 'object'});
81 | const JsonsI = Interface_('jsons', {jsons: 'array', priorityHeaders: 'array', deleteNulls: 'boolean', deleteEmptyArrays: 'boolean'});
82 | const RowsI = Interface_('rows', {rows: 'array'});
83 |
84 | /**
85 | * NOTE: This is the advanced section, consider using global methods at left to get started.
86 | *
87 | * The global methods are just light wrappers for these methods. You can use these methods directly by calling `augment`, which augmented the `Object` and `Array` with a `dottie` namespace which bears these methods.
88 | * @class
89 | */
90 | class Dottie {
91 |
92 | /**
93 | * No need to call this constructor
94 | */
95 | constructor () {
96 |
97 | }
98 |
99 | /**
100 | * @see {@link move}
101 | * @param {Object} params
102 | * @param {String} params.sourcePath
103 | * @param {String} params.destPath
104 | * @param {Object} params.obj
105 | * @return {Object}
106 | */
107 | static move ({sourcePath=MoveI.req, destPath=MoveI.req, obj=MoveI.req, ...kwargs}={}) {
108 | MoveI.extra(kwargs);
109 | MoveI.typecheck(arguments);
110 | return DotObject.move(sourcePath, destPath, obj);
111 | }
112 |
113 | /**
114 | * @see {@link copy}
115 | * @param {Object} params
116 | * @param {Object} params.obj
117 | * @param {String} params.sourcePath
118 | * @param {String} params.target
119 | * @param {String} params.destPath
120 | * @return {Object}
121 | */
122 | static copy ({obj=CopyI.req, sourcePath=CopyI.req, target=CopyI.req, destPath=CopyI.req, ...kwargs}={}) {
123 | CopyI.extra(kwargs);
124 | CopyI.typecheck(arguments);
125 | return DotObject.copy(sourcePath, destPath, obj, target);
126 | }
127 |
128 | /**
129 | * @see {@link transfer}
130 | * @param {Object} params
131 | * @param {String} params.sourcePath
132 | * @param {String} params.destPath
133 | * @param {Object} params.obj
134 | * @param {Object} params.target
135 | * @return {Object}
136 | */
137 | static transfer ({sourcePath=TransferI.req, destPath=TransferI.req, obj=TransferI.req, target=TransferI.req, ...kwargs}={}) {
138 | TransferI.extra(kwargs);
139 | TransferI.typecheck(arguments);
140 | return DotObject.transfer(sourcePath, destPath, obj, target);
141 | }
142 |
143 | /**
144 | * @see {@link expand}
145 | * @param {Object} params
146 | * @param {Object} params.obj
147 | * @returns {Object}
148 | */
149 | static expand ({obj=ExpandI.req, ...kwargs}={}) {
150 | ExpandI.extra(kwargs);
151 | ExpandI.typecheck(arguments);
152 | return DotObject.object(obj);
153 | }
154 |
155 | /**
156 | * @see {@link get}
157 | * @param {Object} params
158 | * @param {String} params.path
159 | * @param {Object} params.obj
160 | * @returns {Any}
161 | */
162 | static get ({path=GetI.req, obj=GetI.req, ...kwargs}={}) {
163 | GetI.extra(kwargs);
164 | GetI.typecheck(arguments);
165 | const result = DotObject.pick(path, obj);
166 | if (result === undefined) return null;
167 | return result;
168 | }
169 |
170 | /**
171 | * @see {@link set}
172 | * @param {Object} params
173 | * @param {String} params.path
174 | * @param {Any} params.value
175 | * @param {Object} params.obj
176 | * @returns {Object}
177 | */
178 | static set ({path=SetI.req, value=SetI.req, obj=SetI.req, ...kwargs}={}) {
179 | SetI.extra(kwargs);
180 | SetI.typecheck(arguments);
181 | return DotObject.str(path, value, obj);
182 | }
183 |
184 | /**
185 | * @see {@link delete_}
186 | * @param {Object} params
187 | * @param {String} params.path
188 | * @param {Object} params.obj
189 | * @returns {Object}
190 | */
191 | static delete ({path=DeleteI.req, obj=DeleteI.req, ...kwargs}={}) {
192 | DeleteI.extra(kwargs);
193 | DeleteI.typecheck(arguments);
194 | return DotObject.delete(path, obj);
195 | }
196 |
197 | /**
198 | * @see {@link remove}
199 | * @param {Object} params
200 | * @param {String} params.path
201 | * @param {Object} params.obj
202 | * @returns {Object}
203 | */
204 | static remove ({path=RemoveI.req, obj=RemoveI.req, ...kwargs}={}) {
205 | RemoveI.extra(kwargs);
206 | RemoveI.typecheck(arguments);
207 | return DotObject.remove(path, obj);
208 | }
209 |
210 | /**
211 | * @see {@link set}
212 | * @param {Object} params
213 | * @param {String} params.path
214 | * @param {Any} params.value
215 | * @param {Object} params.obj
216 | * @returns {Object}
217 | */
218 | static transform ({recipe=TransformI.req, obj=TransformI.req, ...kwargs}={}) {
219 | TransformI.extra(kwargs);
220 | TransformI.typecheck(arguments);
221 | return DotObject.transform(recipe, obj);
222 | }
223 |
224 | /**
225 | * @see {@link dot}
226 | * @param {Object} params
227 | * @param {Object} params.obj
228 | * @returns {Object}
229 | */
230 | static dot ({obj=DotI.req, ...kwargs}={}) {
231 | DotI.extra(kwargs);
232 | DotI.typecheck(arguments);
233 | return DotObject.dot(obj);
234 | }
235 |
236 | /**
237 | * @see {@link jsonsToRows}
238 | * @param {Object} params
239 | * @param {Object[]} params.jsons
240 | * @param {String[]} [params.priorityHeaders=[]]
241 | * @param {Boolean} [params.deleteNulls=false]
242 | * @param {Boolean} [params.deleteEmptyArrays=true]
243 | * @returns {Array[]}
244 | */
245 | static jsonsToRows ({jsons=JsonsI.req, priorityHeaders=[], deleteNulls=false, deleteEmptyArrays=true, ...kwargs}={}) {
246 | JsonsI.extra(kwargs);
247 | JsonsI.typecheck(arguments);
248 | const headers = [];
249 | const values = [];
250 |
251 | // save values as dotted objects and store headers
252 | // remove any nulls
253 | for (const json of jsons) {
254 | const value = DotObject.dot(json);
255 | for (const [k, v] of Object.entries(value)) {
256 | if ( (deleteNulls && v === null) || (deleteEmptyArrays && Array.isArray(v) && v.length===0) ) {
257 | delete value[k];
258 | }
259 | }
260 | headers.push(Object.keys(value));
261 | values.push(value);
262 | }
263 |
264 | // row1 will consist of unique header columns, sorted alphabetically with id first
265 | // use array generics for most efficient manner of doing this
266 | const row1 = [...new Set([].concat(...headers))];
267 | row1.sort();
268 | for (const [i, h] of priorityHeaders.entries()) {
269 | const idx = row1.indexOf(h);
270 | if (idx !== -1) {
271 | row1.splice(idx, 1); // remove
272 | row1.splice(i, 0, h); // insert at front
273 | }
274 |
275 | }
276 |
277 | // the rest of the rows consits of the values in each column, or null if not present
278 | const rows = values.map(value => row1.map(column => value[column] === false ? false : value[column] || null));
279 |
280 | // concat the arrays efficiently for return
281 | return [row1, ...rows];
282 | }
283 |
284 | /**
285 | * @see {@link rowsToJsons}
286 | * @param {Object} params
287 | * @param {Any[][]} params.rows
288 | * @returns {Any[]}
289 | */
290 | static rowsToJsons ({rows=RowsI.req, ...kwargs}={}) {
291 | RowsI.extra(kwargs);
292 | RowsI.typecheck(arguments);
293 | const headers = rows[0];
294 | const objects = [];
295 |
296 | // go through row 1 to end
297 | for (const row of rows.slice(1)) {
298 | const dotted = row.reduce(
299 | function (acc, value, idx) {
300 | // safeguard if for some reason empty string for column or null
301 | const column = headers[idx] || null;
302 | if (!column) return acc;
303 |
304 | // set and return
305 | acc[column] = value;
306 | return acc;
307 | }, {}
308 | );
309 | const obj = DotObject.object(dotted);
310 | objects.push(obj);
311 | }
312 | return objects;
313 | }
314 |
315 | /*
316 | Sets up {}.dottie and [].dottie methods
317 | @param {Any} O - Pass your `Object`
318 | @param {Any} A - Pass your `Array`
319 | */
320 | static augment (O=null, A=null) {
321 | if (O === null) O = Object;
322 | if (A === null) A = Array;
323 | const me = this;
324 | !A.prototype.dottie && Object.defineProperty(A.prototype, 'dottie', {
325 | get: function () {
326 | return {
327 | jsonsToRows: ({priorityHeaders=[], ...kwargs}={}) => {
328 | return me.jsonsToRows({jsons:this, priorityHeaders});
329 | },
330 | rowsToJsons: ({...kwargs}={}) => {
331 | return me.rowsToJsons({rows: this});
332 | }
333 | };
334 | }
335 | });
336 |
337 | !O.prototype.dottie && Object.defineProperty(O.prototype, 'dottie', {
338 | get: function () {
339 | return {
340 | set: ({path, value}={}) => {
341 | return DotObject.str(path, value, this);
342 | },
343 | get: ({path}={}) => {
344 | return DotObject.pick(path, this);
345 | },
346 | move: ({path, destPath}={}) => {
347 | return DotObject.move(path, destPath, this);
348 | },
349 | copy: ({path, destPath, target}={}) => {
350 | return DotObject.copy(path, destPath, this, target);
351 | },
352 | transfer: ({path, destPath, target}={}) => {
353 | return DotObject.transfer(path, destPath, this, target);
354 | },
355 | expand: () => {
356 | return DotObject.object(this);
357 | },
358 | delete: ({path}={}) => {
359 | return DotObject.delete(path, this);
360 | },
361 | remove: ({path}) => {
362 | return DotObject.remove(path, this);
363 | },
364 | transform: ({recipe}={}) => {
365 | return DotObject.transform(recipe, this);
366 | },
367 | dot: ({target, path}={}) => {
368 | return DotObject.dot(this, target, path);
369 | }
370 | };
371 | }
372 | });
373 | }
374 |
375 | }
376 |
377 | export {Dottie};
378 |
379 |
380 |