@robinpath/json - npm Package Compare versions

Comparing version

0.1.0

0.1.1

+37

-7

package.json

		{
		"name": "@robinpath/json",
		"version": "0.1.0",
		"publishConfig": { "access": "public" },
		"version": "0.1.1",
		"publishConfig": {
		"access": "public"
		},
		"type": "module",
		"main": "dist/index.js",
		"types": "dist/index.d.ts",
		"exports": { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } },
		"files": ["dist"],
		"scripts": { "build": "tsc", "test": "node --import tsx --test tests/*.test.ts" },
		"peerDependencies": { "@wiredwp/robinpath": ">=0.20.0" },
		"devDependencies": { "@wiredwp/robinpath": "^0.30.1", "tsx": "^4.19.0", "typescript": "^5.6.0" }
		"exports": {
		".": {
		"import": "./dist/index.js",
		"types": "./dist/index.d.ts"
		}
		},
		"files": [
		"dist"
		],
		"scripts": {
		"build": "tsc",
		"test": "node --import tsx --test tests/*.test.ts"
		},
		"peerDependencies": {
		"@robinpath/core": ">=0.20.0"
		},
		"devDependencies": {
		"@robinpath/core": "^0.30.1",
		"tsx": "^4.19.0",
		"typescript": "^5.6.0"
		},
		"description": "JSON manipulation: parse, stringify, deep merge, flatten, unflatten, diff, query by path, pick, and omit",
		"keywords": [
		"json",
		"utility"
		],
		"license": "MIT",
		"robinpath": {
		"category": "utility",
		"type": "utility",
		"auth": "none",
		"functionCount": 13
		}
		}

-6

dist/index.d.ts

		import type { ModuleAdapter } from "@wiredwp/robinpath";
		declare const JsonModule: ModuleAdapter;
		export default JsonModule;
		export { JsonModule };
		export { JsonFunctions, JsonFunctionMetadata, JsonModuleMetadata } from "./json.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,QAAA,MAAM,UAAU,EAAE,aAMjB,CAAC;AAEF,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}

-12

dist/index.js

		import { JsonFunctions, JsonFunctionMetadata, JsonModuleMetadata } from "./json.js";
		const JsonModule = {
		name: "json",
		functions: JsonFunctions,
		functionMetadata: JsonFunctionMetadata,
		moduleMetadata: JsonModuleMetadata,
		global: false,
		}; // as ModuleAdapter
		export default JsonModule;
		export { JsonModule };
		export { JsonFunctions, JsonFunctionMetadata, JsonModuleMetadata } from "./json.js";
		//# sourceMappingURL=index.js.map

-1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpF,MAAM,UAAU,GAAkB;IAChC,IAAI,EAAE,MAAM;IACZ,SAAS,EAAE,aAAa;IACxB,gBAAgB,EAAE,oBAA2B;IAC7C,cAAc,EAAE,kBAAyB;IACzC,MAAM,EAAE,KAAK;CACd,CAAC,CAAC,mBAAmB;AAEtB,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}

-186

dist/json.d.ts

		import type { BuiltinHandler } from "@wiredwp/robinpath";
		export declare const JsonFunctions: Record<string, BuiltinHandler>;
		export declare const JsonFunctionMetadata: {
		parse: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		stringify: {
		description: string;
		parameters: ({
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		defaultValue?: undefined;
		} \| {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		defaultValue: string;
		})[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		get: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		set: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		merge: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		flatten: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		unflatten: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		diff: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		clone: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		isValid: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		keys: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		pick: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		omit: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		};
		export declare const JsonModuleMetadata: {
		description: string;
		methods: string[];
		};
		//# sourceMappingURL=json.d.ts.map

-1

dist/json.d.ts.map

{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAoC,MAAM,oBAAoB,CAAC;AA0J3F,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAExD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAchC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;CAG9B,CAAC"}

-176

dist/json.js

		function resolvePath(obj, path) {
		const keys = path.split(".");
		let current = obj;
		for (const key of keys) {
		if (current == null \|\| typeof current !== "object")
		return undefined;
		current = current[key];
		}
		return current;
		}
		function setPath(obj, path, value) {
		const clone = JSON.parse(JSON.stringify(obj));
		const keys = path.split(".");
		let current = clone;
		for (let i = 0; i < keys.length - 1; i++) {
		const key = keys[i];
		if (current[key] == null \|\| typeof current[key] !== "object") {
		current[key] = {};
		}
		current = current[key];
		}
		current[keys[keys.length - 1]] = value;
		return clone;
		}
		function deepMerge(target, ...sources) {
		const result = { ...target };
		for (const source of sources) {
		for (const key of Object.keys(source)) {
		const targetVal = result[key];
		const sourceVal = source[key];
		if (targetVal && sourceVal && typeof targetVal === "object" && typeof sourceVal === "object" && !Array.isArray(targetVal) && !Array.isArray(sourceVal)) {
		result[key] = deepMerge(targetVal, sourceVal);
		}
		else {
		result[key] = sourceVal;
		}
		}
		}
		return result;
		}
		function flattenObj(obj, prefix = "") {
		const result = {};
		if (obj == null \|\| typeof obj !== "object" \|\| Array.isArray(obj))
		return result;
		for (const [key, value] of Object.entries(obj)) {
		const newKey = prefix ? `${prefix}.${key}` : key;
		if (value && typeof value === "object" && !Array.isArray(value)) {
		Object.assign(result, flattenObj(value, newKey));
		}
		else {
		result[newKey] = value;
		}
		}
		return result;
		}
		function unflattenObj(obj) {
		const result = {};
		for (const [key, value] of Object.entries(obj)) {
		const keys = key.split(".");
		let current = result;
		for (let i = 0; i < keys.length - 1; i++) {
		const k = keys[i];
		if (!current[k] \|\| typeof current[k] !== "object")
		current[k] = {};
		current = current[k];
		}
		current[keys[keys.length - 1]] = value;
		}
		return result;
		}
		function diffObjects(a, b, path = "") {
		const diffs = [];
		const aObj = a;
		const bObj = b;
		const allKeys = new Set([...Object.keys(aObj ?? {}), ...Object.keys(bObj ?? {})]);
		for (const key of allKeys) {
		const fullPath = path ? `${path}.${key}` : key;
		const aVal = aObj?.[key];
		const bVal = bObj?.[key];
		if (aVal && bVal && typeof aVal === "object" && typeof bVal === "object" && !Array.isArray(aVal) && !Array.isArray(bVal)) {
		diffs.push(...diffObjects(aVal, bVal, fullPath));
		}
		else if (JSON.stringify(aVal) !== JSON.stringify(bVal)) {
		diffs.push({ path: fullPath, oldValue: aVal, newValue: bVal });
		}
		}
		return diffs;
		}
		function collectKeys(obj, prefix = "") {
		const keys = [];
		if (obj == null \|\| typeof obj !== "object" \|\| Array.isArray(obj))
		return keys;
		for (const [key, value] of Object.entries(obj)) {
		const fullKey = prefix ? `${prefix}.${key}` : key;
		keys.push(fullKey);
		if (value && typeof value === "object" && !Array.isArray(value)) {
		keys.push(...collectKeys(value, fullKey));
		}
		}
		return keys;
		}
		// ── Handlers ────────────────────────────────────────────────────────
		const parse = (args) => JSON.parse(String(args[0] ?? ""));
		const stringify = (args) => {
		const indent = args[1] != null ? Number(args[1]) : 2;
		return JSON.stringify(args[0], null, indent);
		};
		const get = (args) => resolvePath(args[0], String(args[1] ?? ""));
		const set = (args) => setPath(args[0], String(args[1] ?? ""), args[2]);
		const merge = (args) => {
		const objects = args.filter((a) => a && typeof a === "object");
		if (objects.length === 0)
		return {};
		return objects.reduce((acc, obj) => deepMerge(acc, obj));
		};
		const flatten = (args) => flattenObj(args[0]);
		const unflatten = (args) => unflattenObj(args[0]);
		const diff = (args) => diffObjects(args[0], args[1]);
		const clone = (args) => JSON.parse(JSON.stringify(args[0]));
		const isValid = (args) => {
		try {
		JSON.parse(String(args[0] ?? ""));
		return true;
		}
		catch {
		return false;
		}
		};
		const keys = (args) => collectKeys(args[0]);
		const pick = (args) => {
		const obj = args[0];
		const pickKeys = args[1];
		if (!obj \|\| !Array.isArray(pickKeys))
		return {};
		const result = {};
		for (const key of pickKeys) {
		if (key in obj)
		result[key] = obj[key];
		}
		return result;
		};
		const omit = (args) => {
		const obj = args[0];
		const omitKeys = new Set(args[1]);
		if (!obj \|\| !omitKeys.size)
		return { ...obj };
		const result = {};
		for (const [key, value] of Object.entries(obj)) {
		if (!omitKeys.has(key))
		result[key] = value;
		}
		return result;
		};
		export const JsonFunctions = {
		parse, stringify, get, set, merge, flatten, unflatten, diff, clone, isValid, keys, pick, omit,
		};
		export const JsonFunctionMetadata = {
		parse: { description: "Parse a JSON string into an object", parameters: [{ name: "jsonString", dataType: "string", description: "JSON string to parse", formInputType: "textarea", required: true }], returnType: "object", returnDescription: "Parsed JavaScript value", example: 'json.parse \'{"name":"Alice"}\'' },
		stringify: { description: "Convert a value to a JSON string", parameters: [{ name: "value", dataType: "any", description: "Value to stringify", formInputType: "json", required: true }, { name: "indent", dataType: "number", description: "Indentation spaces (default: 2)", formInputType: "number", required: false, defaultValue: "2" }], returnType: "string", returnDescription: "JSON string", example: "json.stringify $obj" },
		get: { description: "Get a nested value by dot-separated path", parameters: [{ name: "obj", dataType: "object", description: "Source object", formInputType: "json", required: true }, { name: "path", dataType: "string", description: "Dot-separated path (e.g. user.name)", formInputType: "text", required: true }], returnType: "any", returnDescription: "Value at the path", example: 'json.get $obj "user.name"' },
		set: { description: "Set a nested value by dot-separated path, returning a new object", parameters: [{ name: "obj", dataType: "object", description: "Source object", formInputType: "json", required: true }, { name: "path", dataType: "string", description: "Dot-separated path", formInputType: "text", required: true }, { name: "value", dataType: "any", description: "Value to set", formInputType: "text", required: true }], returnType: "object", returnDescription: "New object with the value set", example: 'json.set $obj "user.name" "Bob"' },
		merge: { description: "Deep merge two or more objects", parameters: [{ name: "objects", dataType: "object", description: "Objects to merge (pass multiple args)", formInputType: "json", required: true }], returnType: "object", returnDescription: "Merged object", example: "json.merge $obj1 $obj2" },
		flatten: { description: "Flatten a nested object to dot-notation keys", parameters: [{ name: "obj", dataType: "object", description: "Object to flatten", formInputType: "json", required: true }], returnType: "object", returnDescription: "Flat object with dot-notation keys", example: "json.flatten $obj" },
		unflatten: { description: "Unflatten dot-notation keys back to a nested object", parameters: [{ name: "obj", dataType: "object", description: "Flat object with dot-notation keys", formInputType: "json", required: true }], returnType: "object", returnDescription: "Nested object", example: "json.unflatten $flat" },
		diff: { description: "Compare two objects and return differences", parameters: [{ name: "a", dataType: "object", description: "First object", formInputType: "json", required: true }, { name: "b", dataType: "object", description: "Second object", formInputType: "json", required: true }], returnType: "array", returnDescription: "Array of {path, oldValue, newValue}", example: "json.diff $obj1 $obj2" },
		clone: { description: "Deep clone an object", parameters: [{ name: "obj", dataType: "any", description: "Value to clone", formInputType: "json", required: true }], returnType: "any", returnDescription: "Deep cloned value", example: "json.clone $obj" },
		isValid: { description: "Check if a string is valid JSON", parameters: [{ name: "str", dataType: "string", description: "String to check", formInputType: "textarea", required: true }], returnType: "boolean", returnDescription: "True if valid JSON", example: 'json.isValid \'{"a":1}\'' },
		keys: { description: "Get all keys including nested paths with dot notation", parameters: [{ name: "obj", dataType: "object", description: "Source object", formInputType: "json", required: true }], returnType: "array", returnDescription: "Array of all key paths", example: "json.keys $obj" },
		pick: { description: "Pick specific keys from an object", parameters: [{ name: "obj", dataType: "object", description: "Source object", formInputType: "json", required: true }, { name: "keys", dataType: "array", description: "Array of keys to pick", formInputType: "json", required: true }], returnType: "object", returnDescription: "Object with only picked keys", example: 'json.pick $obj ["name", "age"]' },
		omit: { description: "Omit specific keys from an object", parameters: [{ name: "obj", dataType: "object", description: "Source object", formInputType: "json", required: true }, { name: "keys", dataType: "array", description: "Array of keys to omit", formInputType: "json", required: true }], returnType: "object", returnDescription: "Object without omitted keys", example: 'json.omit $obj ["password"]' },
		};
		export const JsonModuleMetadata = {
		description: "JSON manipulation: parse, stringify, deep merge, flatten, unflatten, diff, query by path, pick, and omit",
		methods: ["parse", "stringify", "get", "set", "merge", "flatten", "unflatten", "diff", "clone", "isValid", "keys", "pick", "omit"],
		};
		//# sourceMappingURL=json.js.map

-1

dist/json.js.map

@robinpath/json - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics