emdash 0.22.0 → 0.24.0

package/src/components/index.ts

@@ -36,6 +36,7 @@ export { default as EmDashImage } from "./EmDashImage.astro";
 export { default as EmDashMedia } from "./EmDashMedia.astro";
 
 // Portable Text block type components
+export { default as Block } from "./Block.astro";
 export { default as Image } from "./Image.astro";
 export { default as Code } from "./Code.astro";
 export { default as Embed } from "./Embed.astro";
@@ -57,6 +58,7 @@ export { default as Underline } from "./marks/Underline.astro";
 export { default as StrikeThrough } from "./marks/StrikeThrough.astro";
 export { default as Link } from "./marks/Link.astro";
 
+import BlockComponent from "./Block.astro";
 import BreakComponent from "./Break.astro";
 import ButtonComponent from "./Button.astro";
 import ButtonsComponent from "./Buttons.astro";
@@ -77,11 +79,14 @@ import TableComponent from "./Table.astro";
  * Pre-configured components for EmDash Portable Text content
  *
  * Includes renderers for:
+ * - Block styles: paragraph, h1..h6, blockquote — with `textAlign` honoured
+ *   as a WordPress-style `has-text-align-{value}` class (#1201)
  * - Block types: image, code, embed, gallery, columns, break, htmlBlock, table,
  *   button, buttons, cover, file, pullquote
  * - Marks: superscript, subscript, underline, strike-through, link
  */
 export const emdashComponents = {
+	block: BlockComponent,
 	type: {
 		image: ImageComponent,
 		code: CodeComponent,

package/src/components/portable-text-text-align.ts

@@ -0,0 +1,38 @@
+/**
+ * Maps a Portable Text block's `textAlign` to a WordPress-style class name
+ * (`has-text-align-{value}`) for public rendering. Used by the Portable Text
+ * `Block` override in `./Block.astro`.
+ *
+ * `left` is the document default and intentionally does not produce a class —
+ * this matches the converter's omit-on-default rule (see
+ * `src/content/converters/prosemirror-to-portable-text.ts`) so untouched
+ * content stays bytewise identical and renders without an extra class.
+ *
+ * Related: https://github.com/emdash-cms/emdash/issues/1201
+ */
+
+type AlignClassName = "has-text-align-center" | "has-text-align-right" | "has-text-align-justify";
+
+const ALIGN_CLASS_MAP: Record<string, AlignClassName> = {
+	center: "has-text-align-center",
+	right: "has-text-align-right",
+	justify: "has-text-align-justify",
+};
+
+/**
+ * Returns the CSS class for a textAlign value, or `undefined` when no class
+ * should be emitted (default left, missing, or unknown values).
+ *
+ * Allowlist-only by design: arbitrary strings are rejected so a hand-edited
+ * or imported Portable Text block cannot inject attacker-controlled class
+ * names into the rendered HTML.
+ */
+export function textAlignClassName(value: string | undefined): AlignClassName | undefined {
+	if (value === undefined) return undefined;
+	// `Object.hasOwn` (not `in`) so prototype keys like "toString" or
+	// "constructor" can't slip through as valid alignments.
+	if (Object.hasOwn(ALIGN_CLASS_MAP, value)) {
+		return ALIGN_CLASS_MAP[value];
+	}
+	return undefined;
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -164,7 +164,10 @@ function convertTextBlock(block: PortableTextTextBlock): ProseMirrorNode | null
 			const level = parseInt(style.substring(1), 10);
 			return {
 				type: "heading",
-				attrs: { level },
+				attrs: {
+					level,
+					...(block.textAlign ? { textAlign: block.textAlign } : {}),
+				},
 				content: content.length > 0 ? content : undefined,
 			};
 		}
@@ -184,6 +187,7 @@ function convertTextBlock(block: PortableTextTextBlock): ProseMirrorNode | null
 		default:
 			return {
 				type: "paragraph",
+				attrs: block.textAlign ? { textAlign: block.textAlign } : undefined,
 				content: content.length > 0 ? content : undefined,
 			};
 	}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -106,12 +106,16 @@ function convertParagraph(node: ProseMirrorNode): PortableTextTextBlock | null {
 		return null;
 	}
 
+	const ta = node.attrs?.textAlign;
+	const textAlign = ta === "center" || ta === "right" || ta === "justify" ? ta : undefined;
+
 	return {
 		_type: "block",
 		_key: generateKey(),
 		style: "normal",
 		children,
 		markDefs: markDefs.length > 0 ? markDefs : undefined,
+		...(textAlign ? { textAlign } : {}),
 	};
 }
 
@@ -147,12 +151,16 @@ function convertHeading(node: ProseMirrorNode): PortableTextTextBlock | null {
 		return null;
 	}
 
+	const ta = node.attrs?.textAlign;
+	const textAlign = ta === "center" || ta === "right" || ta === "justify" ? ta : undefined;
+
 	return {
 		_type: "block",
 		_key: generateKey(),
 		style,
 		children,
 		markDefs: markDefs.length > 0 ? markDefs : undefined,
+		...(textAlign ? { textAlign } : {}),
 	};
 }
 

package/src/content/converters/types.ts

@@ -43,6 +43,7 @@ export interface PortableTextTextBlock {
 	level?: number;
 	children: PortableTextSpan[];
 	markDefs?: PortableTextMarkDef[];
+	textAlign?: "left" | "center" | "right" | "justify";
 }
 
 /**

package/src/database/migrations/045_taxonomy_parent_group.ts

@@ -0,0 +1,68 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+/**
+ * Store the parent's `translation_group` in `taxonomies.parent_id` instead of a
+ * locale-bound row id.
+ *
+ * Before this, a term's `parent_id` pointed at one specific parent *row* (one
+ * locale). A child translated in another locale could end up parented to a row
+ * in a different locale, silently flattening that locale's tree (#1347). Every
+ * other taxonomy i18n relationship already keys off `translation_group`
+ * (`content_taxonomies.taxonomy_id`, `_emdash_menu_items.reference_id`), so this
+ * aligns parentage with that model: a child links to the parent *concept* and
+ * stays nested in whichever locale that parent has been translated into.
+ *
+ * Backfill rewrites every existing `parent_id` from the referenced parent row's
+ * id to that parent's `translation_group`. A `translation_group` normally equals
+ * its anchor row's id, so the self-FK on `parent_id` stays valid. We only
+ * rewrite when that anchor row still exists; if a parent's anchor was deleted
+ * but a sibling translation survives, the existing locale-bound id is left as-is
+ * rather than rewritten to a dangling FK value. Such a child then renders as a
+ * root rather than nested — an accepted degradation for an already-inconsistent
+ * dataset (its `translation_group` already points at a deleted row, which breaks
+ * `content_taxonomies` joins too). New deletes can't recreate this state: a
+ * parent with children in any locale is undeletable. The correlated subquery is
+ * a no-op for rows that already hold a group (an anchor row's id resolves to
+ * itself), so the migration is safe to re-run.
+ *
+ * Dialect-independent: the correlated-subquery `UPDATE` runs on SQLite (incl.
+ * D1) and Postgres alike.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		UPDATE taxonomies
+		SET parent_id = (
+			SELECT p.translation_group FROM taxonomies p WHERE p.id = taxonomies.parent_id
+		)
+		WHERE parent_id IS NOT NULL
+			AND EXISTS (
+				SELECT 1 FROM taxonomies p
+				WHERE p.id = taxonomies.parent_id
+					AND p.translation_group IS NOT NULL
+					-- Only rewrite to a translation_group that is itself a live row
+					-- id, so the self-FK on parent_id can never dangle.
+					AND EXISTS (SELECT 1 FROM taxonomies a WHERE a.id = p.translation_group)
+			)
+	`.execute(db);
+}
+
+/**
+ * Map each `parent_id` group back to the row id of the parent in the same
+ * locale (the pre-migration shape). Rows with no same-locale parent are left as
+ * they are rather than nulled, so a rollback never silently detaches a subtree.
+ */
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		UPDATE taxonomies
+		SET parent_id = COALESCE(
+			(
+				SELECT c.id FROM taxonomies c
+				WHERE c.translation_group = taxonomies.parent_id
+					AND c.locale = taxonomies.locale
+			),
+			parent_id
+		)
+		WHERE parent_id IS NOT NULL
+	`.execute(db);
+}

package/src/database/migrations/runner.ts

@@ -46,6 +46,7 @@ import * as m041 from "./041_content_locale_list_index.js";
 import * as m042 from "./042_byline_fields.js";
 import * as m043 from "./043_content_references.js";
 import * as m044 from "./044_comment_reactions.js";
+import * as m045 from "./045_taxonomy_parent_group.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -91,6 +92,7 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"042_byline_fields": m042,
 	"043_content_references": m043,
 	"044_comment_reactions": m044,
+	"045_taxonomy_parent_group": m045,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */

package/src/database/repositories/byline.ts

@@ -37,6 +37,8 @@ type BylineRow = Selectable<BylineTable>;
 type BylineRowWithAvatar = BylineRow & {
 	avatar_storage_key?: string | null;
 	avatar_alt?: string | null;
+	avatar_blurhash?: string | null;
+	avatar_dominant_color?: string | null;
 };
 
 export interface CreateBylineInput {
@@ -113,6 +115,8 @@ function rowToByline(row: BylineRowWithAvatar): BylineSummary {
 		avatarMediaId: row.avatar_media_id,
 		avatarStorageKey: row.avatar_storage_key ?? null,
 		avatarAlt: row.avatar_alt ?? null,
+		avatarBlurhash: row.avatar_blurhash ?? null,
+		avatarDominantColor: row.avatar_dominant_color ?? null,
 		websiteUrl: row.website_url,
 		userId: row.user_id,
 		isGuest: row.is_guest === 1,
@@ -944,6 +948,8 @@ export class BylineRepository {
 				"b.avatar_media_id as avatar_media_id",
 				"m.storage_key as avatar_storage_key",
 				"m.alt as avatar_alt",
+				"m.blurhash as avatar_blurhash",
+				"m.dominant_color as avatar_dominant_color",
 				"b.website_url as website_url",
 				"b.user_id as user_id",
 				"b.is_guest as is_guest",
@@ -971,6 +977,8 @@ export class BylineRepository {
 			avatar_media_id: row.avatar_media_id,
 			avatar_storage_key: row.avatar_storage_key,
 			avatar_alt: row.avatar_alt,
+			avatar_blurhash: row.avatar_blurhash,
+			avatar_dominant_color: row.avatar_dominant_color,
 			website_url: row.website_url,
 			user_id: row.user_id,
 			is_guest: row.is_guest,
@@ -1080,6 +1088,8 @@ export class BylineRepository {
 					"b.avatar_media_id as avatar_media_id",
 					"m.storage_key as avatar_storage_key",
 					"m.alt as avatar_alt",
+					"m.blurhash as avatar_blurhash",
+					"m.dominant_color as avatar_dominant_color",
 					"b.website_url as website_url",
 					"b.user_id as user_id",
 					"b.is_guest as is_guest",
@@ -1104,6 +1114,8 @@ export class BylineRepository {
 				avatar_media_id: row.avatar_media_id,
 				avatar_storage_key: row.avatar_storage_key,
 				avatar_alt: row.avatar_alt,
+				avatar_blurhash: row.avatar_blurhash,
+				avatar_dominant_color: row.avatar_dominant_color,
 				website_url: row.website_url,
 				user_id: row.user_id,
 				is_guest: row.is_guest,
@@ -1182,6 +1194,8 @@ export class BylineRepository {
 					"b.avatar_media_id as avatar_media_id",
 					"m.storage_key as avatar_storage_key",
 					"m.alt as avatar_alt",
+					"m.blurhash as avatar_blurhash",
+					"m.dominant_color as avatar_dominant_color",
 					"b.website_url as website_url",
 					"b.user_id as user_id",
 					"b.is_guest as is_guest",

package/src/database/repositories/taxonomy.ts

@@ -64,7 +64,13 @@ export class TaxonomyRepository {
 
 		// Empty-string parentId is coerced to null defensively. Higher layers
 		// also normalize this — see handleTermCreate / handleTermUpdate.
-		const parentId = input.parentId === undefined || input.parentId === "" ? null : input.parentId;
+		// `parent_id` stores the parent's locale-agnostic translation_group (not a
+		// row id), mirroring content_taxonomies.taxonomy_id, so a child stays
+		// nested in every locale's tree. resolveTranslationGroup accepts either a
+		// row id or an already-resolved group, so this is idempotent.
+		const parentInput =
+			input.parentId === undefined || input.parentId === "" ? null : input.parentId;
+		const parentId = parentInput ? await this.resolveParentRef(parentInput) : null;
 
 		let translationGroup = id;
 		if (input.translationOf) {
@@ -150,14 +156,26 @@ export class TaxonomyRepository {
 		return rows.map((row) => this.rowToTaxonomy(row));
 	}
 
-	async findChildren(parentId: string): Promise<Taxonomy[]> {
-		const rows = await this.db
+	/**
+	 * Children of a term. Accepts a term id OR a translation_group and resolves
+	 * to the group, since `parent_id` stores the parent's translation_group.
+	 * Pass `locale` to scope to one locale's tree (children share the parent's
+	 * group across locales); omit it to find children in every locale (used to
+	 * block deletes that would orphan a sibling translation's subtree).
+	 */
+	async findChildren(parentIdOrGroup: string, locale?: string): Promise<Taxonomy[]> {
+		const group = await this.resolveTranslationGroup(parentIdOrGroup);
+		if (!group) return [];
+
+		let query = this.db
 			.selectFrom("taxonomies")
 			.selectAll()
-			.where("parent_id", "=", parentId)
+			.where("parent_id", "=", group)
 			.orderBy("label", "asc")
-			.orderBy("id", "asc")
-			.execute();
+			.orderBy("id", "asc");
+		if (locale !== undefined) query = query.where("locale", "=", locale);
+
+		const rows = await query.execute();
 		return rows.map((row) => this.rowToTaxonomy(row));
 	}
 
@@ -184,7 +202,12 @@ export class TaxonomyRepository {
 		if (input.label !== undefined) updates.label = input.label;
 		if (input.parentId !== undefined) {
 			// Defense in depth: empty-string parentId means null (no parent).
-			updates.parent_id = input.parentId === "" ? null : input.parentId;
+			// Otherwise persist the parent's translation_group (locale-agnostic),
+			// matching create() — see the note there.
+			updates.parent_id =
+				input.parentId === "" || input.parentId === null
+					? null
+					: await this.resolveParentRef(input.parentId);
 		}
 		if (input.data !== undefined) updates.data = JSON.stringify(input.data);
 
@@ -394,6 +417,26 @@ export class TaxonomyRepository {
 		return Number(result?.count ?? 0);
 	}
 
+	/**
+	 * Resolve a parent reference (a row id or a translation_group) to the value
+	 * persisted in `parent_id`: the parent's translation_group, which is
+	 * locale-agnostic so the child stays nested in every locale. A
+	 * translation_group normally equals its anchor row's id, which satisfies the
+	 * self-FK on `parent_id`. If that anchor row is missing (a translation whose
+	 * anchor was deleted), fall back to the id we were given so we never write a
+	 * dangling FK value.
+	 */
+	private async resolveParentRef(idOrGroup: string): Promise<string> {
+		const group = await this.resolveTranslationGroup(idOrGroup);
+		if (!group) return idOrGroup;
+		const anchor = await this.db
+			.selectFrom("taxonomies")
+			.select("id")
+			.where("id", "=", group)
+			.executeTakeFirst();
+		return anchor ? group : idOrGroup;
+	}
+
 	private async resolveTranslationGroup(idOrGroup: string): Promise<string | null> {
 		const row = await this.db
 			.selectFrom("taxonomies")

package/src/database/repositories/types.ts

@@ -78,6 +78,19 @@ export interface BylineSummary {
 	avatarStorageKey?: string | null;
 	/** Avatar media alt text, from the same media join. Null when not joined. */
 	avatarAlt?: string | null;
+	/**
+	 * Avatar media blurhash (LQIP placeholder, migration 024), folded in by the
+	 * same media join as `avatarStorageKey`. Lets a renderer paint a blurred
+	 * placeholder while the full avatar loads, with no extra media lookup.
+	 * Null when the byline has no avatar, the media row has no blurhash, or the
+	 * byline was loaded through a finder that doesn't join media.
+	 */
+	avatarBlurhash?: string | null;
+	/**
+	 * Avatar media dominant colour (LQIP placeholder, migration 024), from the
+	 * same media join. Null under the same conditions as `avatarBlurhash`.
+	 */
+	avatarDominantColor?: string | null;
 	websiteUrl: string | null;
 	userId: string | null;
 	isGuest: boolean;