@terraforge/terraform 0.0.26 → 0.0.28

package/dist/index.mjs

@@ -235,6 +235,24 @@ const sortStateValues = (values) => {
 		return 0;
 	});
 };
+const tryNormalizeJsonString = (value) => {
+	const trimmed = value.trim();
+	if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) return value;
+	try {
+		return stableStringify(JSON.parse(trimmed));
+	} catch {
+		return value;
+	}
+};
+const uniqueStateValues = (values) => {
+	const seen = /* @__PURE__ */ new Set();
+	return values.filter((value) => {
+		const key = stableStringify(value);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+};
 const encodeDynamicValue = (value) => {
 	return {
 		msgpack: pack(value),
@@ -297,22 +315,34 @@ const hasInputValue = (value) => typeof value !== "undefined";
 const shouldIncludeFieldForComparison = (schema, inputValue) => {
 	return schema.required || hasInputValue(inputValue);
 };
+const isContainerSchema = (schema) => {
+	return [
+		"array",
+		"record",
+		"object",
+		"array-object"
+	].includes(schema.type);
+};
 const normalizeStateForComparison = (schema, state, inputState) => {
 	if (!shouldIncludeFieldForComparison(schema, inputState)) return;
+	if ((state === null || typeof state === "undefined") && isContainerSchema(schema) && isEmptyOutputValue(inputState)) state = inputState;
 	if (state === null || typeof state === "undefined") return state;
 	if (schema.type === "array") {
 		if (!Array.isArray(state)) return state;
-		const normalized = state.map((item, index) => {
+		const filtered = state.map((item, index) => {
 			const inputItem = Array.isArray(inputState) ? inputState[index] : void 0;
 			return normalizeStateForComparison(schema.item, item, inputItem);
-		});
-		return schema.collectionKind === "set" ? sortStateValues(normalized) : normalized;
+		}).filter((item) => typeof item !== "undefined");
+		if (schema.collectionKind === "set") return sortStateValues(uniqueStateValues(filtered.filter((item) => item !== null)));
+		return filtered;
 	}
 	if (schema.type === "record") {
 		if (typeof state !== "object" || state === null) return state;
-		return Object.fromEntries(Object.entries(state).map(([key, value]) => {
+		return Object.fromEntries(Object.entries(state).flatMap(([key, value]) => {
 			const inputValue = inputState && typeof inputState === "object" ? inputState[key] : void 0;
-			return [key, normalizeStateForComparison(schema.item, value, inputValue)];
+			const normalized = normalizeStateForComparison(schema.item, value, inputValue);
+			if (typeof normalized === "undefined") return [];
+			return [[key, normalized]];
 		}));
 	}
 	if (schema.type === "object") {
@@ -333,6 +363,9 @@ const normalizeStateForComparison = (schema, state, inputState) => {
 			return [[camelCase(key), normalized]];
 		}));
 	}
+	if (schema.type === "string") {
+		if (typeof state === "string") return tryNormalizeJsonString(state);
+	}
 	return state;
 };
 const formatInputState = (schema, state, includeSchemaFields = true, path = []) => {
@@ -521,7 +554,7 @@ var TerraformProvider = class {
 		if (!refreshedState) return { kind: "deleted" };
 		const normalizedPriorInputState = normalizeStateForComparison(schema, priorInputState, priorInputState);
 		const normalizedRefreshedState = normalizeStateForComparison(schema, refreshedState, priorInputState);
-		if (JSON.stringify(normalizedPriorInputState) === JSON.stringify(normalizedRefreshedState)) return {
+		if (stableStringify(normalizedPriorInputState) === stableStringify(normalizedRefreshedState)) return {
 			kind: "unchanged",
 			state: refreshedState
 		};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terraforge/terraform",
-	"version": "0.0.26",
+	"version": "0.0.28",
 	"type": "module",
 	"repository": {
 		"type": "git",