148 lines
3.6 KiB
TypeScript
148 lines
3.6 KiB
TypeScript
import * as plugins from './smartjson.plugins.js';
|
|
import * as bufferhandling from './bufferhandling.js';
|
|
|
|
interface JsonObject {
|
|
[key: string]: any;
|
|
}
|
|
|
|
/**
|
|
* allows you to parse a json
|
|
*/
|
|
export const parse = bufferhandling.parse;
|
|
|
|
export const parseJsonL = (jsonlData: string): JsonObject[] => {
|
|
const lines = jsonlData.trim().split('\n');
|
|
const parsedData: JsonObject[] = lines.reduce((acc, line) => {
|
|
if (line.trim().length > 0) {
|
|
acc.push(JSON.parse(line));
|
|
}
|
|
return acc;
|
|
}, [] as JsonObject[]);
|
|
return parsedData;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param objArg
|
|
* @param optionsArg
|
|
*/
|
|
export const stringify = (
|
|
objArg: any,
|
|
simpleOrderArray?: string[],
|
|
optionsArg: plugins.IStableJsonTypes['Options'] = {}
|
|
): string => {
|
|
const bufferedJson = bufferhandling.stringify(objArg);
|
|
objArg = JSON.parse(bufferedJson);
|
|
let returnJson = plugins.stableJson(objArg, optionsArg);
|
|
return returnJson;
|
|
};
|
|
|
|
export const stringifyPretty = (objectArg: any) => {
|
|
const stringified = stringify(objectArg);
|
|
const object = JSON.parse(stringified);
|
|
return JSON.stringify(object, null, 2);
|
|
}
|
|
|
|
export const stringifyBase64 = (...args: Parameters<typeof stringify>): string => {
|
|
const stringifiedResult = stringify(...args);
|
|
return plugins.smartstring.base64.encodeUri(stringifiedResult);
|
|
};
|
|
|
|
export const parseBase64 = (base64JsonStringArg: string) => {
|
|
const simpleStringified = plugins.smartstring.base64.decode(base64JsonStringArg);
|
|
return parse(simpleStringified);
|
|
};
|
|
|
|
parse;
|
|
|
|
export class Smartjson {
|
|
/**
|
|
* enfolds data from an object
|
|
*/
|
|
public static enfoldFromObject(objectArg) {
|
|
const newInstance = new this();
|
|
for (const keyName in objectArg) {
|
|
if (newInstance.saveableProperties.indexOf(keyName) !== -1) {
|
|
newInstance[keyName] = objectArg[keyName];
|
|
}
|
|
}
|
|
return newInstance;
|
|
}
|
|
|
|
/**
|
|
* enfold from json
|
|
*/
|
|
public static enfoldFromJson(jsonArg: string) {
|
|
const objectFromJson = parse(jsonArg);
|
|
return this.enfoldFromObject(objectFromJson);
|
|
}
|
|
|
|
// ========
|
|
// INSTANCE
|
|
// ========
|
|
|
|
public saveableProperties: string[];
|
|
|
|
/**
|
|
* folds a class into an object
|
|
*/
|
|
public foldToObject() {
|
|
const newFoldedObject: { [key: string]: any } = {};
|
|
const trackMap = [];
|
|
for (const keyName of this.saveableProperties) {
|
|
let value = this[keyName];
|
|
if (value instanceof Smartjson) {
|
|
if (trackMap.includes(value)) {
|
|
throw new Error('cycle detected');
|
|
}
|
|
trackMap.push(value);
|
|
value = value.foldToObject();
|
|
}
|
|
newFoldedObject[keyName] = plugins.lodashCloneDeep(value);
|
|
}
|
|
return newFoldedObject;
|
|
}
|
|
|
|
/**
|
|
* folds a class into an object
|
|
*/
|
|
public foldToJson() {
|
|
const foldedObject = this.foldToObject();
|
|
return stringify(foldedObject);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decorator that marks a property as foldable
|
|
*/
|
|
export const foldDec = () => {
|
|
return (target: any, key: string) => {
|
|
if (!target.saveableProperties) {
|
|
target.saveableProperties = [];
|
|
}
|
|
target.saveableProperties.push(key);
|
|
};
|
|
};
|
|
|
|
export const deepEqualObjects = (object1: any, object2: any): boolean => {
|
|
const object1String = stringify(object1);
|
|
const object2String = stringify(object2);
|
|
return object1String === object2String;
|
|
};
|
|
|
|
export const deepEqualJsonLStrings = (jsonLString1: string, jsonLString2: string): boolean => {
|
|
const firstArray = [];
|
|
jsonLString1.split('\n').forEach((line) => {
|
|
if (line) {
|
|
firstArray.push(parse(line));
|
|
}
|
|
});
|
|
const secondArray = [];
|
|
jsonLString2.split('\n').forEach((line) => {
|
|
if (line) {
|
|
secondArray.push(parse(line));
|
|
}
|
|
});
|
|
return deepEqualObjects(firstArray, secondArray);
|
|
}
|