@tsdoctor/snapshot 0.2.0 → 0.2.1

package/content-hash.js

@@ -49,14 +49,89 @@ function hashContent(content) {
 	const normalized = normalizeContent(content);
 	return createHash("sha256").update(normalized).digest("hex");
 }
+const TIMESTAMP_KEYS = /* @__PURE__ */ new Set([
+	"publishedTime",
+	"modifiedTime",
+	"article:published_time",
+	"article:modified_time"
+]);
+const JSON_LD_DATE_KEYS = /* @__PURE__ */ new Set([
+	"datePublished",
+	"dateModified",
+	"uploadDate"
+]);
+const JSON_LD_BODY_KEYS = /* @__PURE__ */ new Set([
+	"children",
+	"innerHTML",
+	"textContent"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Strips a JSON-LD script body of its date fields.
+*
+* @remarks
+* The body arrives as a string, so it must be parsed before its dates can be
+* removed. A body that does not parse as JSON is returned unchanged rather
+* than throwing — an unparseable body is still content worth hashing.
+*/
+function stripJsonLdBody(body) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		return body;
+	}
+	return JSON.stringify(stripTimestamps(parsed));
+}
+/**
+* Recursively removes timestamp-valued entries from a frontmatter value.
+*
+* @remarks
+* Timestamps appear in two shapes. In the meta-pair form the value lives in a
+* `content` field whose sibling `property`/`name` names a timestamp
+* (`article:published_time`, `article:modified_time`). In the JSON-LD form it
+* is an object key (`datePublished`, `dateModified`) inside a script body.
+* Both are stripped; everything else survives so that an `og:image`,
+* `og:description`, canonical `href` or JSON-LD version change is visible to
+* change detection.
+*
+* The walk must be recursive: `head` is an array of `[tagName, attrs]` pairs,
+* so a shallow pass would see nothing.
+*/
+function stripTimestamps(value) {
+	if (Array.isArray(value)) return value.map(stripTimestamps);
+	if (!isRecord(value)) return value;
+	const property = value["property"] ?? value["name"];
+	const isTimestampTag = typeof property === "string" && TIMESTAMP_KEYS.has(property);
+	const isJsonLd = value["type"] === "application/ld+json";
+	const result = {};
+	for (const key of Object.keys(value).sort()) {
+		if (JSON_LD_DATE_KEYS.has(key)) continue;
+		if (isTimestampTag && key === "content") continue;
+		const entry = value[key];
+		if (isJsonLd && JSON_LD_BODY_KEYS.has(key) && typeof entry === "string") {
+			result[key] = stripJsonLdBody(entry);
+			continue;
+		}
+		result[key] = stripTimestamps(entry);
+	}
+	return result;
+}
 /**
 * Generates a SHA-256 hash of frontmatter fields.
 *
 * @remarks
-* Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
+* Excludes the top-level timestamp fields (`publishedTime`, `modifiedTime`,
 * `article:published_time`, `article:modified_time`) to prevent circular
-* dependencies in change detection. Keys are sorted alphabetically before
-* hashing to ensure consistent results regardless of object key order.
+* dependencies in change detection, and strips timestamp-valued entries
+* recursively from every remaining value — including the `head` array's meta
+* pairs and the date fields inside a JSON-LD script body. Everything else in
+* `head` participates in the hash, so an `og:image`, `og:description` or
+* canonical URL change marks the page modified. Keys are sorted
+* alphabetically before hashing to ensure consistent results regardless of
+* object key order.
 *
 * @param frontmatter - The frontmatter object to hash
 * @returns Hexadecimal SHA-256 hash string
@@ -75,15 +150,11 @@ function hashContent(content) {
 */
 function hashFrontmatter(frontmatter) {
 	const filtered = {};
-	for (const [key, value] of Object.entries(frontmatter)) {
-		if (key === "publishedTime" || key === "modifiedTime" || key === "head" || key === "article:published_time" || key === "article:modified_time") continue;
-		filtered[key] = value;
+	for (const key of Object.keys(frontmatter).sort()) {
+		if (TIMESTAMP_KEYS.has(key)) continue;
+		filtered[key] = stripTimestamps(frontmatter[key]);
 	}
-	const sorted = Object.keys(filtered).sort().reduce((acc, key) => {
-		acc[key] = filtered[key];
-		return acc;
-	}, {});
-	const json = JSON.stringify(sorted);
+	const json = JSON.stringify(filtered);
 	return createHash("sha256").update(json).digest("hex");
 }
 

package/index.d.ts

@@ -48,10 +48,15 @@ declare function hashContent(content: string): string;
  * Generates a SHA-256 hash of frontmatter fields.
  *
  * @remarks
- * Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
+ * Excludes the top-level timestamp fields (`publishedTime`, `modifiedTime`,
  * `article:published_time`, `article:modified_time`) to prevent circular
- * dependencies in change detection. Keys are sorted alphabetically before
- * hashing to ensure consistent results regardless of object key order.
+ * dependencies in change detection, and strips timestamp-valued entries
+ * recursively from every remaining value — including the `head` array's meta
+ * pairs and the date fields inside a JSON-LD script body. Everything else in
+ * `head` participates in the hash, so an `og:image`, `og:description` or
+ * canonical URL change marks the page modified. Keys are sorted
+ * alphabetically before hashing to ensure consistent results regardless of
+ * object key order.
  *
  * @param frontmatter - The frontmatter object to hash
  * @returns Hexadecimal SHA-256 hash string

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsdoctor/snapshot",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"private": false,
 	"description": "Incremental-build snapshot tracking for static documentation pipelines: a schema-versioned SQLite store of per-file content hashes and timestamps, built on @effected/store, plus the pure SHA-256 content-hashing helpers that feed it.",
 	"keywords": [