@mintplayer/ng-spark 22.23.0 → 22.25.0

package/fesm2022/mintplayer-ng-spark-moderation.mjs

@@ -0,0 +1,1212 @@
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, Injectable, InjectionToken, computed, effect, inject, input, signal } from "@angular/core";
+import { toSignal } from "@angular/core/rxjs-interop";
+import { ActivatedRoute, NavigationEnd, Router, RouterLink } from "@angular/router";
+import { EMPTY, filter } from "rxjs";
+import { SparkLanguageService, SparkService } from "@mintplayer/ng-spark/services";
+import { TranslateKeyPipe } from "@mintplayer/ng-spark/pipes";
+import { BsCardComponent, BsCardHeaderComponent } from "@mintplayer/ng-bootstrap/card";
+import { DatePipe } from "@angular/common";
+import { provideSparkDetailActions, provideSparkDetailPanels } from "@mintplayer/ng-spark/panels";
+var SparkModerationService = class SparkModerationService {
+	spark = inject(SparkService);
+	pending = /* @__PURE__ */ new Map();
+	flushScheduled = false;
+	router = inject(Router, { optional: true });
+	#votesCast = signal(0, ...ngDevMode ? [{ debugName: "#votesCast" }] : /* istanbul ignore next */ []);
+	votesCast = this.#votesCast.asReadonly();
+	navigated = toSignal(this.router?.events.pipe(filter((e) => e instanceof NavigationEnd)) ?? EMPTY, { initialValue: null });
+	ownReputationChanged = computed(() => ({
+		navigation: this.navigated(),
+		votes: this.#votesCast()
+	}), ...ngDevMode ? [{ debugName: "ownReputationChanged" }] : /* istanbul ignore next */ []);
+	#ownInFlight = null;
+	ownReputation() {
+		return this.#ownInFlight ??= this.reputation().finally(() => this.#ownInFlight = null);
+	}
+	async vote(type, id, direction) {
+		const state = await this.spark.postEnvelope("/moderation/vote", {
+			objectTypeId: type,
+			id,
+			direction
+		});
+		this.#votesCast.update((n) => n + 1);
+		return state;
+	}
+	voteState(type, id) {
+		return new Promise((resolve) => {
+			let byId = this.pending.get(type);
+			if (!byId) this.pending.set(type, byId = /* @__PURE__ */ new Map());
+			const waiting = byId.get(id) ?? [];
+			waiting.push(resolve);
+			byId.set(id, waiting);
+			if (!this.flushScheduled) {
+				this.flushScheduled = true;
+				setTimeout(() => this.flush(), 0);
+			}
+		});
+	}
+	votes(type, ids) {
+		return this.spark.postEnvelope("/moderation/votes", {
+			objectTypeId: type,
+			ids
+		});
+	}
+	flag(type, id, reason) {
+		return this.spark.postEnvelope("/moderation/flag", {
+			objectTypeId: type,
+			id,
+			reason
+		});
+	}
+	lock(type, id, reason) {
+		return this.spark.postEnvelope("/moderation/lock", {
+			objectTypeId: type,
+			id,
+			reason
+		});
+	}
+	unlock(type, id) {
+		return this.spark.postEnvelope("/moderation/unlock", {
+			objectTypeId: type,
+			id
+		});
+	}
+	status(type, id) {
+		return this.spark.postEnvelope("/moderation/status", {
+			objectTypeId: type,
+			id
+		});
+	}
+	reputation(userId) {
+		return this.spark.postEnvelope("/moderation/reputation", userId ? { userId } : {});
+	}
+	history(take = 100) {
+		return this.spark.postEnvelope("/moderation/reputation/history", { take });
+	}
+	cases(status = "open", skip = 0, take = 50) {
+		return this.spark.postEnvelope("/moderation/cases", {
+			status,
+			skip,
+			take
+		});
+	}
+	case(caseId) {
+		return this.spark.postEnvelope("/moderation/case", { caseId });
+	}
+	decide(caseId, decision, accountId, reason) {
+		return this.spark.postEnvelope("/moderation/case/decide", {
+			caseId,
+			decision,
+			accountId,
+			reason
+		});
+	}
+	suspend(userId, days, reason) {
+		return this.spark.postEnvelope("/moderation/suspend", {
+			userId,
+			days: days ?? null,
+			reason
+		});
+	}
+	unsuspend(userId) {
+		return this.spark.postEnvelope("/moderation/unsuspend", { userId });
+	}
+	audit(skip = 0, take = 50) {
+		return this.spark.postEnvelope("/moderation/audit", {
+			skip,
+			take
+		});
+	}
+	flush() {
+		this.flushScheduled = false;
+		const batches = [...this.pending.entries()];
+		this.pending.clear();
+		for (const [type, byId] of batches) {
+			const ids = [...byId.keys()];
+			for (let i = 0; i < ids.length; i += 100) {
+				const chunk = ids.slice(i, i + 100);
+				this.votes(type, chunk).then((states) => {
+					const found = new Map(states.map((s) => [s.id, s]));
+					for (const id of chunk) byId.get(id)?.forEach((resolve) => resolve(found.get(id) ?? null));
+				}, () => {
+					for (const id of chunk) byId.get(id)?.forEach((resolve) => resolve(null));
+				});
+			}
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkModerationService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkModerationService,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkModerationService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const SPARK_MODERATION_REVIEW_PATH = new InjectionToken("SparkModerationReviewPath", { factory: () => "/moderation/review" });
+var SparkVoteComponent = class SparkVoteComponent {
+	moderation = inject(SparkModerationService);
+	value = input(...ngDevMode ? [void 0, { debugName: "value" }] : /* istanbul ignore next */ []);
+	attribute = input(...ngDevMode ? [void 0, { debugName: "attribute" }] : /* istanbul ignore next */ []);
+	column = input(...ngDevMode ? [void 0, { debugName: "column" }] : /* istanbul ignore next */ []);
+	options = input(...ngDevMode ? [void 0, { debugName: "options" }] : /* istanbul ignore next */ []);
+	item = input(...ngDevMode ? [void 0, { debugName: "item" }] : /* istanbul ignore next */ []);
+	state = signal(null, ...ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []);
+	busy = signal(false, ...ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []);
+	error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	target = computed(() => {
+		const item = this.item();
+		const id = item?.["id"];
+		const type = item?.["objectTypeId"] ?? this.options()?.["type"];
+		return id && type ? {
+			id,
+			type
+		} : null;
+	}, ...ngDevMode ? [{ debugName: "target" }] : /* istanbul ignore next */ []);
+	constructor() {
+		effect(() => {
+			const target = this.target();
+			if (!target) return;
+			this.moderation.voteState(target.type, target.id).then((s) => this.state.set(s));
+		});
+	}
+	async cast(direction) {
+		const target = this.target();
+		const current = this.state();
+		if (!target || !current || this.busy()) return;
+		const next = current.myVote === direction ? 0 : direction;
+		this.busy.set(true);
+		this.error.set(null);
+		try {
+			this.state.set(await this.moderation.vote(target.type, target.id, next));
+		} catch (e) {
+			this.error.set(describeModerationError(e));
+		} finally {
+			this.busy.set(false);
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkVoteComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkVoteComponent,
+		isStandalone: true,
+		selector: "spark-vote",
+		inputs: {
+			value: {
+				classPropertyName: "value",
+				publicName: "value",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			attribute: {
+				classPropertyName: "attribute",
+				publicName: "attribute",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			column: {
+				classPropertyName: "column",
+				publicName: "column",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			options: {
+				classPropertyName: "options",
+				publicName: "options",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			item: {
+				classPropertyName: "item",
+				publicName: "item",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		ngImport: i0,
+		template: `
+    @if (state(); as s) {
+      <span class="spark-vote d-inline-flex align-items-center gap-1" [class.spark-vote-locked]="s.locked">
+        <button type="button" class="btn btn-sm spark-vote-up" [class.btn-primary]="s.myVote === 1" [class.btn-outline-secondary]="s.myVote !== 1"
+                [disabled]="busy() || s.locked || (s.canUpvote === false && s.myVote !== 1)" [attr.aria-pressed]="s.myVote === 1" [attr.aria-label]="'moderation.upvote' | t" (click)="cast(1)">▲</button>
+        <span class="spark-vote-score fw-bold" [attr.aria-label]="'moderation.score' | t">{{ s.score }}</span>
+        <button type="button" class="btn btn-sm spark-vote-down" [class.btn-danger]="s.myVote === -1" [class.btn-outline-secondary]="s.myVote !== -1"
+                [disabled]="busy() || s.locked || (s.canDownvote === false && s.myVote !== -1)" [attr.aria-pressed]="s.myVote === -1" [attr.aria-label]="'moderation.downvote' | t" (click)="cast(-1)">▼</button>
+        @if (error(); as message) {
+          <span class="text-danger small spark-vote-error" role="alert">{{ message }}</span>
+        }
+      </span>
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "pipe",
+			type: TranslateKeyPipe,
+			name: "t"
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkVoteComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-vote",
+			imports: [TranslateKeyPipe],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    @if (state(); as s) {
+      <span class="spark-vote d-inline-flex align-items-center gap-1" [class.spark-vote-locked]="s.locked">
+        <button type="button" class="btn btn-sm spark-vote-up" [class.btn-primary]="s.myVote === 1" [class.btn-outline-secondary]="s.myVote !== 1"
+                [disabled]="busy() || s.locked || (s.canUpvote === false && s.myVote !== 1)" [attr.aria-pressed]="s.myVote === 1" [attr.aria-label]="'moderation.upvote' | t" (click)="cast(1)">▲</button>
+        <span class="spark-vote-score fw-bold" [attr.aria-label]="'moderation.score' | t">{{ s.score }}</span>
+        <button type="button" class="btn btn-sm spark-vote-down" [class.btn-danger]="s.myVote === -1" [class.btn-outline-secondary]="s.myVote !== -1"
+                [disabled]="busy() || s.locked || (s.canDownvote === false && s.myVote !== -1)" [attr.aria-pressed]="s.myVote === -1" [attr.aria-label]="'moderation.downvote' | t" (click)="cast(-1)">▼</button>
+        @if (error(); as message) {
+          <span class="text-danger small spark-vote-error" role="alert">{{ message }}</span>
+        }
+      </span>
+    }
+  `
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		value: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "value",
+				required: false
+			}]
+		}],
+		attribute: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "attribute",
+				required: false
+			}]
+		}],
+		column: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "column",
+				required: false
+			}]
+		}],
+		options: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "options",
+				required: false
+			}]
+		}],
+		item: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "item",
+				required: false
+			}]
+		}]
+	}
+});
+function describeModerationError(e) {
+	const err = e;
+	const body = err?.error;
+	const first = body?.result?.errors?.[0]?.errorMessage;
+	if (typeof first === "string") return first;
+	if (first && typeof first === "object") {
+		const values = Object.values(first);
+		if (values.length) return values[0];
+	}
+	return body?.result?.error ?? err?.message ?? "Failed";
+}
+var SparkFlagButtonComponent = class SparkFlagButtonComponent {
+	moderation = inject(SparkModerationService);
+	lang = inject(SparkLanguageService);
+	context = input.required(...ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []);
+	busy = signal(false, ...ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []);
+	done = signal(false, ...ngDevMode ? [{ debugName: "done" }] : /* istanbul ignore next */ []);
+	error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	async flag() {
+		const reason = prompt(this.lang.t("moderation.flagReason"));
+		if (!reason?.trim()) return;
+		const ctx = this.context();
+		this.busy.set(true);
+		this.error.set(null);
+		try {
+			await this.moderation.flag(ctx.type, ctx.id, reason.trim());
+			this.done.set(true);
+		} catch (e) {
+			this.error.set(describeModerationError(e));
+		} finally {
+			this.busy.set(false);
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkFlagButtonComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkFlagButtonComponent,
+		isStandalone: true,
+		selector: "spark-flag-button",
+		inputs: { context: {
+			classPropertyName: "context",
+			publicName: "context",
+			isSignal: true,
+			isRequired: true,
+			transformFunction: null
+		} },
+		ngImport: i0,
+		template: `
+    @if (context().deleted !== 'only') {
+      <span class="d-inline-flex gap-2 align-items-center">
+        <button type="button" class="btn btn-outline-warning spark-flag" [disabled]="busy() || done()" (click)="flag()">
+          {{ 'moderation.flag' | t }}
+        </button>
+        @if (done()) {
+          <span class="small text-success spark-flag-done">{{ 'moderation.flagged' | t }}</span>
+        }
+        @if (error(); as message) {
+          <span class="small text-danger spark-flag-error" role="alert">{{ message }}</span>
+        }
+      </span>
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "pipe",
+			type: TranslateKeyPipe,
+			name: "t"
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkFlagButtonComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-flag-button",
+			imports: [TranslateKeyPipe],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    @if (context().deleted !== 'only') {
+      <span class="d-inline-flex gap-2 align-items-center">
+        <button type="button" class="btn btn-outline-warning spark-flag" [disabled]="busy() || done()" (click)="flag()">
+          {{ 'moderation.flag' | t }}
+        </button>
+        @if (done()) {
+          <span class="small text-success spark-flag-done">{{ 'moderation.flagged' | t }}</span>
+        }
+        @if (error(); as message) {
+          <span class="small text-danger spark-flag-error" role="alert">{{ message }}</span>
+        }
+      </span>
+    }
+  `
+		}]
+	}],
+	propDecorators: { context: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "context",
+			required: true
+		}]
+	}] }
+});
+var SparkModeratorPanelComponent = class SparkModeratorPanelComponent {
+	moderation = inject(SparkModerationService);
+	lang = inject(SparkLanguageService);
+	reviewPath = inject(SPARK_MODERATION_REVIEW_PATH);
+	context = input.required(...ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []);
+	status = signal(null, ...ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []);
+	busy = signal(false, ...ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []);
+	error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	constructor() {
+		effect(() => {
+			const ctx = this.context();
+			if (ctx.deleted === "only") {
+				this.status.set(null);
+				return;
+			}
+			this.moderation.status(ctx.type, ctx.id).then((s) => this.status.set(s), () => this.status.set(null));
+		});
+	}
+	async lock() {
+		const reason = prompt(this.lang.t("moderation.lockReason")) ?? void 0;
+		await this.run(() => this.moderation.lock(this.context().type, this.context().id, reason));
+	}
+	async unlock() {
+		await this.run(() => this.moderation.unlock(this.context().type, this.context().id));
+	}
+	async suspendAuthor(userId) {
+		const answer = prompt(this.lang.t("moderation.suspendDays"));
+		if (answer === null) return;
+		const days = answer.trim() === "" ? null : Number(answer);
+		if (days !== null && !(days > 0)) return;
+		await this.run(() => this.moderation.suspend(userId, days));
+	}
+	async run(work) {
+		this.busy.set(true);
+		this.error.set(null);
+		try {
+			await work();
+			const ctx = this.context();
+			this.status.set(await this.moderation.status(ctx.type, ctx.id));
+			await ctx.reload();
+		} catch (e) {
+			this.error.set(describeModerationError(e));
+		} finally {
+			this.busy.set(false);
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkModeratorPanelComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkModeratorPanelComponent,
+		isStandalone: true,
+		selector: "spark-moderator-panel",
+		inputs: { context: {
+			classPropertyName: "context",
+			publicName: "context",
+			isSignal: true,
+			isRequired: true,
+			transformFunction: null
+		} },
+		ngImport: i0,
+		template: `
+    @if (status(); as s) {
+      @if (s.canLock || s.canReview || s.canSuspend) {
+        <bs-card class="d-block spark-moderator-panel">
+          <bs-card-header>{{ 'moderation.panel' | t }}</bs-card-header>
+          <div class="p-3 d-flex flex-wrap gap-2 align-items-center">
+            @if (s.locked) {
+              <span class="badge bg-secondary spark-moderation-locked">{{ 'moderation.locked' | t }}</span>
+              @if (s.lockReason) { <span class="small text-muted">{{ s.lockReason }}</span> }
+            }
+            @if (s.canLock) {
+              @if (s.locked) {
+                <button type="button" class="btn btn-sm btn-outline-secondary spark-unlock" [disabled]="busy()" (click)="unlock()">{{ 'moderation.unlock' | t }}</button>
+              } @else {
+                <button type="button" class="btn btn-sm btn-outline-secondary spark-lock" [disabled]="busy()" (click)="lock()">{{ 'moderation.lock' | t }}</button>
+              }
+            }
+            @if (s.canReview && s.openFlags > 0) {
+              <a class="btn btn-sm btn-outline-warning spark-open-flags" [routerLink]="reviewPath" [queryParams]="{ case: s.openCaseId }">
+                {{ 'moderation.openFlags' | t }}: {{ s.openFlags }}
+              </a>
+            }
+            @if (s.canSuspend && s.authorId) {
+              <button type="button" class="btn btn-sm btn-outline-danger spark-suspend-author" [disabled]="busy()" (click)="suspendAuthor(s.authorId)">{{ 'moderation.suspendAuthor' | t }}</button>
+            }
+            @if (error(); as message) {
+              <span class="small text-danger" role="alert">{{ message }}</span>
+            }
+          </div>
+        </bs-card>
+      }
+    }
+  `,
+		isInline: true,
+		dependencies: [
+			{
+				kind: "component",
+				type: BsCardComponent,
+				selector: "bs-card",
+				inputs: ["color", "outline"]
+			},
+			{
+				kind: "component",
+				type: BsCardHeaderComponent,
+				selector: "bs-card-header",
+				inputs: ["color", "navStyle"]
+			},
+			{
+				kind: "directive",
+				type: RouterLink,
+				selector: "[routerLink]",
+				inputs: [
+					"target",
+					"queryParams",
+					"fragment",
+					"queryParamsHandling",
+					"state",
+					"info",
+					"relativeTo",
+					"preserveFragment",
+					"skipLocationChange",
+					"replaceUrl",
+					"browserUrl",
+					"routerLink"
+				]
+			},
+			{
+				kind: "pipe",
+				type: TranslateKeyPipe,
+				name: "t"
+			}
+		],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkModeratorPanelComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-moderator-panel",
+			imports: [
+				BsCardComponent,
+				BsCardHeaderComponent,
+				TranslateKeyPipe,
+				RouterLink
+			],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    @if (status(); as s) {
+      @if (s.canLock || s.canReview || s.canSuspend) {
+        <bs-card class="d-block spark-moderator-panel">
+          <bs-card-header>{{ 'moderation.panel' | t }}</bs-card-header>
+          <div class="p-3 d-flex flex-wrap gap-2 align-items-center">
+            @if (s.locked) {
+              <span class="badge bg-secondary spark-moderation-locked">{{ 'moderation.locked' | t }}</span>
+              @if (s.lockReason) { <span class="small text-muted">{{ s.lockReason }}</span> }
+            }
+            @if (s.canLock) {
+              @if (s.locked) {
+                <button type="button" class="btn btn-sm btn-outline-secondary spark-unlock" [disabled]="busy()" (click)="unlock()">{{ 'moderation.unlock' | t }}</button>
+              } @else {
+                <button type="button" class="btn btn-sm btn-outline-secondary spark-lock" [disabled]="busy()" (click)="lock()">{{ 'moderation.lock' | t }}</button>
+              }
+            }
+            @if (s.canReview && s.openFlags > 0) {
+              <a class="btn btn-sm btn-outline-warning spark-open-flags" [routerLink]="reviewPath" [queryParams]="{ case: s.openCaseId }">
+                {{ 'moderation.openFlags' | t }}: {{ s.openFlags }}
+              </a>
+            }
+            @if (s.canSuspend && s.authorId) {
+              <button type="button" class="btn btn-sm btn-outline-danger spark-suspend-author" [disabled]="busy()" (click)="suspendAuthor(s.authorId)">{{ 'moderation.suspendAuthor' | t }}</button>
+            }
+            @if (error(); as message) {
+              <span class="small text-danger" role="alert">{{ message }}</span>
+            }
+          </div>
+        </bs-card>
+      }
+    }
+  `
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { context: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "context",
+			required: true
+		}]
+	}] }
+});
+var SparkReputationBadgeComponent = class SparkReputationBadgeComponent {
+	moderation = inject(SparkModerationService);
+	userId = input(...ngDevMode ? [void 0, { debugName: "userId" }] : /* istanbul ignore next */ []);
+	reputation = signal(null, ...ngDevMode ? [{ debugName: "reputation" }] : /* istanbul ignore next */ []);
+	constructor() {
+		effect(() => {
+			const userId = this.userId() ?? void 0;
+			(userId ? this.moderation.reputation(userId) : (this.moderation.ownReputationChanged(), this.moderation.ownReputation())).then((r) => this.reputation.set(r), () => this.reputation.set(null));
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkReputationBadgeComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkReputationBadgeComponent,
+		isStandalone: true,
+		selector: "spark-reputation-badge",
+		inputs: { userId: {
+			classPropertyName: "userId",
+			publicName: "userId",
+			isSignal: true,
+			isRequired: false,
+			transformFunction: null
+		} },
+		ngImport: i0,
+		template: `
+    @if (reputation(); as r) {
+      <span class="badge bg-body-tertiary text-body border spark-reputation-badge" [attr.title]="'moderation.reputation' | t">
+        {{ r.total }}
+        @if (!userId() && r.pending) {
+          <!-- A received downvote makes the pending part negative: "(-2 pending)", never "(+-2 pending)". -->
+          <span class="text-muted spark-reputation-pending">({{ r.pending > 0 ? '+' : '' }}{{ r.pending }} {{ 'moderation.pending' | t }})</span>
+        }
+      </span>
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "pipe",
+			type: TranslateKeyPipe,
+			name: "t"
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkReputationBadgeComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-reputation-badge",
+			imports: [TranslateKeyPipe],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    @if (reputation(); as r) {
+      <span class="badge bg-body-tertiary text-body border spark-reputation-badge" [attr.title]="'moderation.reputation' | t">
+        {{ r.total }}
+        @if (!userId() && r.pending) {
+          <!-- A received downvote makes the pending part negative: "(-2 pending)", never "(+-2 pending)". -->
+          <span class="text-muted spark-reputation-pending">({{ r.pending > 0 ? '+' : '' }}{{ r.pending }} {{ 'moderation.pending' | t }})</span>
+        }
+      </span>
+    }
+  `
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { userId: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "userId",
+			required: false
+		}]
+	}] }
+});
+var SparkReviewQueueComponent = class SparkReviewQueueComponent {
+	moderation = inject(SparkModerationService);
+	route = inject(ActivatedRoute);
+	router = inject(Router);
+	spark = inject(SparkService);
+	cases = signal([], ...ngDevMode ? [{ debugName: "cases" }] : /* istanbul ignore next */ []);
+	targets = signal({}, ...ngDevMode ? [{ debugName: "targets" }] : /* istanbul ignore next */ []);
+	selected = signal(null, ...ngDevMode ? [{ debugName: "selected" }] : /* istanbul ignore next */ []);
+	busy = signal(false, ...ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []);
+	error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	async ngOnInit() {
+		await this.load();
+		const requested = this.route.snapshot.queryParamMap.get("case");
+		if (requested) await this.open(requested);
+	}
+	async open(caseId) {
+		await this.run(async () => {
+			this.selected.set(await this.moderation.case(caseId));
+			await this.router.navigate([], {
+				relativeTo: this.route,
+				queryParams: { case: caseId },
+				replaceUrl: true
+			});
+		});
+	}
+	async decide(decision, accountId) {
+		const current = this.selected();
+		if (!current) return;
+		await this.run(async () => {
+			await this.moderation.decide(current.case.id, decision, accountId);
+			this.selected.set(await this.moderation.case(current.case.id));
+			await this.load();
+		});
+	}
+	async load() {
+		await this.run(async () => this.cases.set(await this.moderation.cases("open")));
+		this.resolveTargets(this.cases());
+	}
+	async resolveTargets(cases) {
+		const pending = cases.filter((c) => c.targetId && c.targetType && !(c.id in this.targets()));
+		if (!pending.length) return;
+		let types = [];
+		try {
+			types = await this.spark.getEntityTypes();
+		} catch {
+			return;
+		}
+		await Promise.all(pending.map(async (c) => {
+			const type = types.find((t) => t.name === c.targetType || t.id === c.targetType || t.alias === c.targetType);
+			const route = type ? type.alias || type.id : null;
+			let title = null;
+			if (route) try {
+				title = (await this.spark.get(route, c.targetId)).breadcrumb || null;
+			} catch {}
+			const link = route && title ? [
+				"/po",
+				route,
+				c.targetId
+			] : null;
+			this.targets.update((t) => ({
+				...t,
+				[c.id]: {
+					title,
+					link
+				}
+			}));
+		}));
+	}
+	async run(work) {
+		this.busy.set(true);
+		this.error.set(null);
+		try {
+			await work();
+		} catch (e) {
+			this.error.set(describeModerationError(e));
+		} finally {
+			this.busy.set(false);
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkReviewQueueComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkReviewQueueComponent,
+		isStandalone: true,
+		selector: "spark-review-queue",
+		ngImport: i0,
+		template: `
+    <div class="container-fluid spark-review-queue">
+      <h1 class="h3">{{ 'moderation.reviewQueue' | t }}</h1>
+      @if (error(); as message) { <div class="alert alert-danger" role="alert">{{ message }}</div> }
+      <div class="row g-3">
+        <div class="col-md-4">
+          @for (c of cases(); track c.id) {
+            <button type="button" class="list-group-item list-group-item-action w-100 text-start p-2 border mb-1 spark-case"
+                    [class.active]="selected()?.case?.id === c.id" (click)="open(c.id)">
+              <strong>{{ c.kind }}</strong>
+              @if (c.flagCount) { <span class="badge text-bg-warning ms-1">{{ c.flagCount }}</span> }
+              @if (targets()[c.id]?.title; as title) { <div class="small fw-semibold text-truncate spark-case-target">{{ title }}</div> }
+              <div class="small">{{ c.summary }}</div>
+              <div class="small text-muted">{{ c.openedAtUtc | date: 'short' }}</div>
+            </button>
+          } @empty {
+            <p class="text-muted spark-no-cases">{{ 'moderation.noCases' | t }}</p>
+          }
+        </div>
+        <div class="col-md-8">
+          @if (selected(); as d) {
+            <bs-card class="d-block spark-case-detail">
+              <bs-card-header>{{ 'moderation.rule' | t }}: {{ d.case.kind }} — {{ d.case.summary }}</bs-card-header>
+              <div class="p-3">
+                @if (targets()[d.case.id]; as target) {
+                  <p class="spark-case-target-link">
+                    @if (target.link) { <a [routerLink]="target.link">{{ target.title ?? d.case.targetId }}</a> }
+                    @else { {{ target.title ?? d.case.targetId }} }
+                  </p>
+                }
+                @if (d.accounts.length) {
+                  <h2 class="h6">{{ 'moderation.accounts' | t }}</h2>
+                  <table class="table table-sm spark-case-accounts">
+                    <thead><tr><th></th><th>{{ 'moderation.ageDays' | t }}</th><th></th><th>{{ 'moderation.sharesNetwork' | t }}</th><th>{{ 'moderation.repBefore' | t }}</th><th>{{ 'moderation.repAfter' | t }}</th></tr></thead>
+                    <tbody>
+                      @for (a of d.accounts; track a.id) {
+                        <tr><td>{{ a.id }}</td><td>{{ a.ageDays }}</td><td>{{ a.registrationMethod }}</td><td>{{ a.sharesNetworkWith }}</td><td>{{ a.reputationBefore }}</td><td>{{ a.reputationAfter }}</td></tr>
+                      }
+                    </tbody>
+                  </table>
+                }
+                @if (d.matrix.length) {
+                  <h2 class="h6">{{ 'moderation.matrix' | t }}</h2>
+                  <ul class="small spark-case-matrix">
+                    @for (m of d.matrix; track m.voterId + m.authorId) { <li>{{ m.voterId }} → {{ m.authorId }}: {{ m.votes }}</li> }
+                  </ul>
+                }
+                @if (d.timeline.length) {
+                  <h2 class="h6">{{ 'moderation.timeline' | t }}</h2>
+                  <table class="table table-sm small spark-case-timeline">
+                    <tbody>
+                      @for (t of d.timeline; track t.voteId) {
+                        <tr><td>{{ t.castAtUtc | date: 'short' }}</td><td>{{ t.voterId }} → {{ t.authorId }}</td><td>{{ t.direction > 0 ? '▲' : t.direction < 0 ? '▼' : '·' }}</td><td>{{ t.secondsAfterPost ?? '' }} s</td></tr>
+                      }
+                    </tbody>
+                  </table>
+                }
+                @if (d.flags.length) {
+                  <ul class="small spark-case-flags">
+                    @for (f of d.flags; track f.flaggerId) { <li>{{ f.reason }} <span class="text-muted">({{ f.raisedAtUtc | date: 'short' }})</span></li> }
+                  </ul>
+                }
+                @if (d.case.status === 'open') {
+                  <div class="d-flex flex-wrap gap-2">
+                    @if (d.case.kind === 'flag') {
+                      <button type="button" class="btn btn-sm btn-success spark-decide-uphold" [disabled]="busy()" (click)="decide('uphold')">{{ 'moderation.uphold' | t }}</button>
+                      <button type="button" class="btn btn-sm btn-outline-secondary spark-decide-decline" [disabled]="busy()" (click)="decide('decline')">{{ 'moderation.decline' | t }}</button>
+                    } @else {
+                      <button type="button" class="btn btn-sm btn-outline-secondary spark-decide-dismiss" [disabled]="busy()" (click)="decide('dismiss')">{{ 'moderation.dismiss' | t }}</button>
+                      <button type="button" class="btn btn-sm btn-warning spark-decide-reverse" [disabled]="busy()" (click)="decide('reverse')">{{ 'moderation.reverse' | t }}</button>
+                      @for (a of d.case.accountIds; track a) {
+                        <button type="button" class="btn btn-sm btn-outline-danger spark-decide-merge" [disabled]="busy()" (click)="decide('merge', a)">{{ 'moderation.merge' | t }}: {{ a }}</button>
+                        <button type="button" class="btn btn-sm btn-danger spark-decide-suspend" [disabled]="busy()" (click)="decide('suspend', a)">{{ 'moderation.suspend' | t }}: {{ a }}</button>
+                      }
+                    }
+                  </div>
+                }
+              </div>
+            </bs-card>
+          }
+        </div>
+      </div>
+    </div>
+  `,
+		isInline: true,
+		dependencies: [
+			{
+				kind: "component",
+				type: BsCardComponent,
+				selector: "bs-card",
+				inputs: ["color", "outline"]
+			},
+			{
+				kind: "component",
+				type: BsCardHeaderComponent,
+				selector: "bs-card-header",
+				inputs: ["color", "navStyle"]
+			},
+			{
+				kind: "directive",
+				type: RouterLink,
+				selector: "[routerLink]",
+				inputs: [
+					"target",
+					"queryParams",
+					"fragment",
+					"queryParamsHandling",
+					"state",
+					"info",
+					"relativeTo",
+					"preserveFragment",
+					"skipLocationChange",
+					"replaceUrl",
+					"browserUrl",
+					"routerLink"
+				]
+			},
+			{
+				kind: "pipe",
+				type: TranslateKeyPipe,
+				name: "t"
+			},
+			{
+				kind: "pipe",
+				type: DatePipe,
+				name: "date"
+			}
+		],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkReviewQueueComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-review-queue",
+			imports: [
+				BsCardComponent,
+				BsCardHeaderComponent,
+				RouterLink,
+				TranslateKeyPipe,
+				DatePipe
+			],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: `
+    <div class="container-fluid spark-review-queue">
+      <h1 class="h3">{{ 'moderation.reviewQueue' | t }}</h1>
+      @if (error(); as message) { <div class="alert alert-danger" role="alert">{{ message }}</div> }
+      <div class="row g-3">
+        <div class="col-md-4">
+          @for (c of cases(); track c.id) {
+            <button type="button" class="list-group-item list-group-item-action w-100 text-start p-2 border mb-1 spark-case"
+                    [class.active]="selected()?.case?.id === c.id" (click)="open(c.id)">
+              <strong>{{ c.kind }}</strong>
+              @if (c.flagCount) { <span class="badge text-bg-warning ms-1">{{ c.flagCount }}</span> }
+              @if (targets()[c.id]?.title; as title) { <div class="small fw-semibold text-truncate spark-case-target">{{ title }}</div> }
+              <div class="small">{{ c.summary }}</div>
+              <div class="small text-muted">{{ c.openedAtUtc | date: 'short' }}</div>
+            </button>
+          } @empty {
+            <p class="text-muted spark-no-cases">{{ 'moderation.noCases' | t }}</p>
+          }
+        </div>
+        <div class="col-md-8">
+          @if (selected(); as d) {
+            <bs-card class="d-block spark-case-detail">
+              <bs-card-header>{{ 'moderation.rule' | t }}: {{ d.case.kind }} — {{ d.case.summary }}</bs-card-header>
+              <div class="p-3">
+                @if (targets()[d.case.id]; as target) {
+                  <p class="spark-case-target-link">
+                    @if (target.link) { <a [routerLink]="target.link">{{ target.title ?? d.case.targetId }}</a> }
+                    @else { {{ target.title ?? d.case.targetId }} }
+                  </p>
+                }
+                @if (d.accounts.length) {
+                  <h2 class="h6">{{ 'moderation.accounts' | t }}</h2>
+                  <table class="table table-sm spark-case-accounts">
+                    <thead><tr><th></th><th>{{ 'moderation.ageDays' | t }}</th><th></th><th>{{ 'moderation.sharesNetwork' | t }}</th><th>{{ 'moderation.repBefore' | t }}</th><th>{{ 'moderation.repAfter' | t }}</th></tr></thead>
+                    <tbody>
+                      @for (a of d.accounts; track a.id) {
+                        <tr><td>{{ a.id }}</td><td>{{ a.ageDays }}</td><td>{{ a.registrationMethod }}</td><td>{{ a.sharesNetworkWith }}</td><td>{{ a.reputationBefore }}</td><td>{{ a.reputationAfter }}</td></tr>
+                      }
+                    </tbody>
+                  </table>
+                }
+                @if (d.matrix.length) {
+                  <h2 class="h6">{{ 'moderation.matrix' | t }}</h2>
+                  <ul class="small spark-case-matrix">
+                    @for (m of d.matrix; track m.voterId + m.authorId) { <li>{{ m.voterId }} → {{ m.authorId }}: {{ m.votes }}</li> }
+                  </ul>
+                }
+                @if (d.timeline.length) {
+                  <h2 class="h6">{{ 'moderation.timeline' | t }}</h2>
+                  <table class="table table-sm small spark-case-timeline">
+                    <tbody>
+                      @for (t of d.timeline; track t.voteId) {
+                        <tr><td>{{ t.castAtUtc | date: 'short' }}</td><td>{{ t.voterId }} → {{ t.authorId }}</td><td>{{ t.direction > 0 ? '▲' : t.direction < 0 ? '▼' : '·' }}</td><td>{{ t.secondsAfterPost ?? '' }} s</td></tr>
+                      }
+                    </tbody>
+                  </table>
+                }
+                @if (d.flags.length) {
+                  <ul class="small spark-case-flags">
+                    @for (f of d.flags; track f.flaggerId) { <li>{{ f.reason }} <span class="text-muted">({{ f.raisedAtUtc | date: 'short' }})</span></li> }
+                  </ul>
+                }
+                @if (d.case.status === 'open') {
+                  <div class="d-flex flex-wrap gap-2">
+                    @if (d.case.kind === 'flag') {
+                      <button type="button" class="btn btn-sm btn-success spark-decide-uphold" [disabled]="busy()" (click)="decide('uphold')">{{ 'moderation.uphold' | t }}</button>
+                      <button type="button" class="btn btn-sm btn-outline-secondary spark-decide-decline" [disabled]="busy()" (click)="decide('decline')">{{ 'moderation.decline' | t }}</button>
+                    } @else {
+                      <button type="button" class="btn btn-sm btn-outline-secondary spark-decide-dismiss" [disabled]="busy()" (click)="decide('dismiss')">{{ 'moderation.dismiss' | t }}</button>
+                      <button type="button" class="btn btn-sm btn-warning spark-decide-reverse" [disabled]="busy()" (click)="decide('reverse')">{{ 'moderation.reverse' | t }}</button>
+                      @for (a of d.case.accountIds; track a) {
+                        <button type="button" class="btn btn-sm btn-outline-danger spark-decide-merge" [disabled]="busy()" (click)="decide('merge', a)">{{ 'moderation.merge' | t }}: {{ a }}</button>
+                        <button type="button" class="btn btn-sm btn-danger spark-decide-suspend" [disabled]="busy()" (click)="decide('suspend', a)">{{ 'moderation.suspend' | t }}: {{ a }}</button>
+                      }
+                    }
+                  </div>
+                }
+              </div>
+            </bs-card>
+          }
+        </div>
+      </div>
+    </div>
+  `
+		}]
+	}]
+});
+var SparkReviewQueueLinkComponent = class SparkReviewQueueLinkComponent {
+	moderation = inject(SparkModerationService);
+	linkClass = input("", ...ngDevMode ? [{ debugName: "linkClass" }] : /* istanbul ignore next */ []);
+	canReview = signal(false, ...ngDevMode ? [{ debugName: "canReview" }] : /* istanbul ignore next */ []);
+	constructor() {
+		effect(() => {
+			this.moderation.ownReputationChanged();
+			this.moderation.ownReputation().then((r) => this.canReview.set(r.canReview === true), () => this.canReview.set(false));
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: SparkReviewQueueLinkComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: SparkReviewQueueLinkComponent,
+		isStandalone: true,
+		selector: "spark-review-queue-link",
+		inputs: { linkClass: {
+			classPropertyName: "linkClass",
+			publicName: "linkClass",
+			isSignal: true,
+			isRequired: false,
+			transformFunction: null
+		} },
+		host: { properties: { "style.display": "canReview() ? null : \"none\"" } },
+		ngImport: i0,
+		template: `
+    @if (canReview()) {
+      <a class="spark-review-queue-link" [class]="linkClass()" routerLink="/moderation/review">{{ 'moderation.reviewQueue' | t }}</a>
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "directive",
+			type: RouterLink,
+			selector: "[routerLink]",
+			inputs: [
+				"target",
+				"queryParams",
+				"fragment",
+				"queryParamsHandling",
+				"state",
+				"info",
+				"relativeTo",
+				"preserveFragment",
+				"skipLocationChange",
+				"replaceUrl",
+				"browserUrl",
+				"routerLink"
+			]
+		}, {
+			kind: "pipe",
+			type: TranslateKeyPipe,
+			name: "t"
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: SparkReviewQueueLinkComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "spark-review-queue-link",
+			imports: [RouterLink, TranslateKeyPipe],
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			host: { "[style.display]": "canReview() ? null : \"none\"" },
+			template: `
+    @if (canReview()) {
+      <a class="spark-review-queue-link" [class]="linkClass()" routerLink="/moderation/review">{{ 'moderation.reviewQueue' | t }}</a>
+    }
+  `
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { linkClass: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "linkClass",
+			required: false
+		}]
+	}] }
+});
+function provideSparkModeration(options) {
+	return [
+		...provideSparkDetailActions({
+			id: "spark-moderation-flag",
+			component: SparkFlagButtonComponent,
+			priority: 90
+		}),
+		...provideSparkDetailPanels({
+			id: "spark-moderation-panel",
+			component: SparkModeratorPanelComponent,
+			order: options?.panelOrder ?? 90
+		}),
+		{
+			provide: SPARK_MODERATION_REVIEW_PATH,
+			useValue: options?.reviewPath ?? "/moderation/review"
+		}
+	];
+}
+const sparkModerationRenderers = [{
+	name: "spark-vote",
+	detailComponent: SparkVoteComponent,
+	columnComponent: SparkVoteComponent
+}];
+function sparkModerationRoutes(path = "moderation/review") {
+	return [{
+		path,
+		component: SparkReviewQueueComponent
+	}];
+}
+export { SPARK_MODERATION_REVIEW_PATH, SparkFlagButtonComponent, SparkModerationService, SparkModeratorPanelComponent, SparkReputationBadgeComponent, SparkReviewQueueComponent, SparkReviewQueueLinkComponent, SparkVoteComponent, describeModerationError, provideSparkModeration, sparkModerationRenderers, sparkModerationRoutes };
+
+//# sourceMappingURL=mintplayer-ng-spark-moderation.mjs.map