@phosart/common 0.4.22

package/src/lib/server/theme/schema.ts

@@ -0,0 +1,286 @@
+import { writeFileSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import z from 'zod';
+import { $DATA } from '../directories.ts';
+import { parse, stringify } from 'yaml';
+import { Logger } from 'tslog';
+import { getLogLevel } from '../util.ts';
+const ThemeLogger = new Logger({ minLevel: getLogLevel() });
+
+const $THEMESCHEMA = () => path.resolve($DATA(), '.theme-schema.json');
+const $TYPE = () => path.resolve($DATA(), 'generated-schema.ts');
+const $THEMECONFIG = () => path.resolve($DATA(), 'theme-config.yaml');
+const BLANK = `{
+  "$schema": "https://raw.githubusercontent.com/PhosphoriteArt/phosart-common/refs/heads/main/settings.schema.json"
+}`;
+
+const ZColorOption = z.object({ type: z.literal('color') });
+const ZSelectionOption = z.object({
+	type: z.literal('selection'),
+	options: z.array(z.string()),
+	multi: z.literal(false).optional()
+});
+const ZMultiSelectionOption = z.object({
+	type: z.literal('selection'),
+	options: z.array(z.string()),
+	multi: z.literal(true)
+});
+const ZStringOption = z.object({ type: z.literal('string') });
+const ZTagsOption = z.object({ type: z.literal('tag-list') });
+const ZStringList = z.object({ type: z.literal('string-list') });
+export const ZThemeSettingsSchema = z.record(
+	z.string(),
+	z.union([
+		ZColorOption,
+		ZSelectionOption,
+		ZMultiSelectionOption,
+		ZTagsOption,
+		ZStringList,
+		ZStringOption
+	])
+);
+
+export type ThemeSettingsSchema = z.infer<typeof ZThemeSettingsSchema>;
+
+export const builtinSettings = {
+	defaultArtist: { type: 'string' }
+} as const satisfies ThemeSettingsSchema;
+export type BuiltinSettings = typeof builtinSettings;
+
+type MaterializedOptionFor<T extends ThemeSettingsSchema[string]> =
+	T extends z.infer<typeof ZColorOption>
+		? `#${string}`
+		: T extends z.infer<typeof ZSelectionOption>
+			? [...T['options']]
+			: T extends z.infer<typeof ZMultiSelectionOption>
+				? Array<[...T['options']]>
+				: T extends z.infer<typeof ZStringList>
+					? Array<string>
+					: T extends z.infer<typeof ZTagsOption>
+						? Array<string>
+						: T extends z.infer<typeof ZStringOption>
+							? string
+							: never;
+
+export type SettingsFor<T extends ThemeSettingsSchema> = {
+	[K in keyof T]: MaterializedOptionFor<T[K]>;
+};
+
+export async function readThemeSchema<T extends ThemeSettingsSchema>(): Promise<T> {
+	let text: string;
+	try {
+		text = await readFile($THEMESCHEMA(), { encoding: 'utf-8' });
+	} catch (err) {
+		ThemeLogger.warn('Error reading theme file:', err, 'recreating');
+		await writeFile($THEMESCHEMA(), BLANK, { encoding: 'utf-8' });
+		text = BLANK;
+	}
+	try {
+		const data = JSON.parse(text);
+		if (typeof data === 'object') {
+			delete data['$schema'];
+		}
+		const settings = await ZThemeSettingsSchema.parseAsync(data);
+		await writeGeneratedSchema(settings);
+		return settings as T;
+	} catch (err) {
+		ThemeLogger.warn('Error parsing theme file:', err);
+		throw err;
+	}
+}
+
+function escape(token: string): string {
+	return token.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+async function writeGeneratedSchema<T extends ThemeSettingsSchema>(schema: T) {
+	let ts = `export interface ThemeSchema {`;
+
+	for (const [k, v] of Object.entries(schema)) {
+		switch (v.type) {
+			case 'color':
+				ts += `\n  "${escape(k)}": \`#\${string}\`;`;
+				break;
+			case 'selection': {
+				const opts = v.options
+					.map(escape)
+					.map((k) => `"${k}"`)
+					.join(' | ');
+				const typ = v.multi ? `Array<${opts}>` : opts;
+				ts += `\n  "${escape(k)}": ` + typ + ';';
+				break;
+			}
+			case 'string':
+				ts += `\n  "${escape(k)}": string;`;
+				break;
+			case 'string-list':
+			case 'tag-list':
+				ts += `\n  "${escape(k)}": string[]`;
+				break;
+		}
+	}
+
+	if (Object.keys(schema).length === 0) {
+		ts = 'export type ThemeSchema = Record<string, never>;\n';
+	} else {
+		ts += '\n}\n';
+	}
+
+	await writeFile($TYPE(), ts, { encoding: 'utf-8' });
+}
+
+export function validateSchema<T extends ThemeSettingsSchema>(
+	schema: T,
+	doc: unknown
+): doc is SettingsFor<T & BuiltinSettings> {
+	return doValidateSchema(Object.assign({}, builtinSettings, schema), doc);
+}
+
+function doValidateSchema<T extends ThemeSettingsSchema>(
+	schema: T,
+	doc: unknown
+): doc is SettingsFor<T> {
+	if (typeof doc !== 'object' || !doc) {
+		throw new Error(
+			"document '" +
+				JSON.stringify(doc) +
+				"' is not a truthy object and thus cannot conform to schema " +
+				JSON.stringify(schema)
+		);
+	}
+	const cast = doc as Record<string, unknown>;
+
+	for (const [k, v] of Object.entries(schema)) {
+		if (k in cast) {
+			const docval: unknown = cast[k];
+			switch (v.type) {
+				case 'color':
+					if (typeof docval !== 'string' || !docval.startsWith('#')) {
+						throw new Error(
+							"document '" +
+								JSON.stringify(doc) +
+								"' @ key '" +
+								k +
+								"' does not have type color (instead has value '" +
+								v +
+								"') and thus does not conform to schema " +
+								JSON.stringify(schema)
+						);
+					}
+					break;
+				case 'selection':
+					if (v.multi) {
+						if (
+							!Array.isArray(docval) ||
+							docval.some((item) => typeof item !== 'string' || !v.options.includes(item))
+						) {
+							throw new Error(
+								"document '" +
+									JSON.stringify(doc) +
+									"' @ key '" +
+									k +
+									"' does not have a valid selection list at that key (instead has value '" +
+									v +
+									"') and thus does not conform to schema " +
+									JSON.stringify(schema)
+							);
+						}
+						break;
+					}
+					if (typeof docval !== 'string' || !v.options.includes(docval)) {
+						throw new Error(
+							"document '" +
+								JSON.stringify(doc) +
+								"' @ key '" +
+								k +
+								"' does not have a valid selection at that key (instead has value '" +
+								v +
+								"') and thus does not conform to schema " +
+								JSON.stringify(schema)
+						);
+					}
+					break;
+				case 'string':
+					if (typeof docval !== 'string') {
+						throw new Error(
+							"document '" +
+								JSON.stringify(doc) +
+								"' @ key '" +
+								k +
+								"' does not have a valid string at that key (instead has value '" +
+								v +
+								"') and thus does not conform to schema " +
+								JSON.stringify(schema)
+						);
+					}
+					break;
+				case 'string-list':
+				case 'tag-list':
+					if (!Array.isArray(docval) || docval.some((item) => typeof item !== 'string')) {
+						throw new Error(
+							"document '" +
+								JSON.stringify(doc) +
+								"' @ key '" +
+								k +
+								"' does not have a valid string list at that key (instead has value '" +
+								v +
+								"') and thus does not conform to schema " +
+								JSON.stringify(schema)
+						);
+					}
+			}
+		}
+	}
+	return true;
+}
+
+export async function readThemeConfig<T extends ThemeSettingsSchema>(
+	schema: T
+): Promise<SettingsFor<T & BuiltinSettings>> {
+	let text: string;
+	try {
+		text = await readFile($THEMECONFIG(), { encoding: 'utf-8' });
+	} catch (err) {
+		ThemeLogger.warn('Error reading theme file:', err, 'recreating');
+		await writeFile($THEMECONFIG(), '', { encoding: 'utf-8' });
+		text = '';
+	}
+	try {
+		const doc = parse(text) ?? {};
+		if (validateSchema(schema, doc)) {
+			return doc;
+		}
+
+		throw new Error('unreachable');
+	} catch (err) {
+		ThemeLogger.warn('Error parsing theme file:', err);
+		throw err;
+	}
+}
+
+export async function writeThemeConfig<T extends ThemeSettingsSchema>(
+	schema: T,
+	config: SettingsFor<T & BuiltinSettings>
+): Promise<void> {
+	if (validateSchema(schema, config)) {
+		await writeFile($THEMECONFIG(), stringify(config), { encoding: 'utf-8' });
+	}
+}
+
+function writeJsonSchema() {
+	const p = path.resolve(path.join(import.meta.dirname, '../../../settings.schema.json'));
+	writeFileSync(
+		p,
+		JSON.stringify(
+			z.intersection(z.object({ $schema: z.string() }), ZThemeSettingsSchema).toJSONSchema(),
+			null,
+			2
+		),
+		{ encoding: 'utf-8' }
+	);
+	console.log('Wrote jsonschema to ' + p);
+}
+
+if (process.env.WRITE_SCHEMA) {
+	writeJsonSchema();
+}

package/src/lib/server/util.ts

@@ -0,0 +1,102 @@
+import * as fs from 'node:fs/promises';
+import * as crypto from 'node:crypto';
+import path from 'node:path';
+import { $DATA } from './directories.ts';
+import type { GalleryCache, RawGalleryCache } from './gallery.ts';
+import type { CharacterCache, RawCharacterCache } from './character.ts';
+import type { ArtistCache } from './artist.ts';
+import { $ART } from './index.ts';
+
+export async function hashUrl(url: string) {
+	const buf = await fs.readFile(url);
+	return crypto.createHash('md5').update(buf).digest('hex').substring(24);
+}
+
+export function hash(object: object) {
+	return crypto.createHash('md5').update(JSON.stringify(object)).digest('hex').substring(24);
+}
+
+export function relPath(startFile: string, nextFile: string) {
+	const out = path.join(path.dirname(startFile), nextFile);
+	return out;
+}
+export function fullPath(startFile: string, nextFile: string) {
+	const out = path.join($DATA(), path.dirname(startFile), nextFile);
+	return out;
+}
+
+type FileStructure = {
+	[name: string]: FileStructure | string;
+};
+
+async function getStructureHash(scanPath?: string): Promise<FileStructure> {
+	const list = await fs.readdir(scanPath ?? $ART(), { withFileTypes: true });
+	const structure: FileStructure = {};
+
+	for (const element of list) {
+		const next = path.join(scanPath ?? $ART(), element.name);
+		if (element.isDirectory()) {
+			structure[element.name] = await getStructureHash(next);
+		} else if (element.isFile() && /\.(gallery|character|yaml|yml)$/gi.test(element.name)) {
+			structure[element.name] = await hashUrl(next);
+		}
+	}
+
+	return structure;
+}
+
+interface Cache<T> {
+	cache: T | null;
+	version: string | null;
+}
+
+export interface GlobalCache {
+	galleryCache: Cache<GalleryCache>;
+	rawGalleryCache: Cache<RawGalleryCache>;
+	characterCache: Cache<CharacterCache>;
+	rawCharacterCache: Cache<RawCharacterCache>;
+	artistCache: Cache<ArtistCache>;
+}
+
+export async function cacheVersion(): Promise<string> {
+	return hash(await getStructureHash());
+}
+
+export function getCache(): GlobalCache {
+	if (typeof global == 'undefined') {
+		throw new Error('global is undefined');
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let cache: GlobalCache | undefined = (global as any).__art_global_cache;
+	if (!cache) {
+		cache = {
+			galleryCache: { cache: null, version: null },
+			characterCache: { cache: null, version: null },
+			rawCharacterCache: { cache: null, version: null },
+			artistCache: { cache: null, version: null },
+			rawGalleryCache: { cache: null, version: null }
+		};
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		(global as any).__art_global_cache = cache;
+	}
+
+	return cache;
+}
+
+export function clearCache() {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(global as any).__art_global_cache = null;
+}
+
+export function getLogLevel(defaultLevel: number = 3): number {
+	try {
+		if (!process.env.LOG_LEVEL) {
+			return defaultLevel;
+		}
+
+		return parseInt(process.env.LOG_LEVEL);
+	} catch {
+		return defaultLevel;
+	}
+}

package/src/lib/util/art.ts

@@ -0,0 +1,136 @@
+import type { z } from 'zod';
+
+import type { FullCharacter } from '../server/models/Character.ts';
+import type { Artist as ZArtist } from '../server/models/Artist.ts';
+import type {
+	Picture as ZPicture,
+	Image as ZImage,
+	Source as ZSource
+} from '../server/models/image.ts';
+import type {
+	FullGallery,
+	FullArtPiece,
+	BaseArtPiece as ZBaseArtPiece,
+	RawGallery as ZRawGallery,
+	BaseArtist as ZBaseArtist,
+	BaseGallery as ZBaseGallery,
+	ExtendedGallery as ZExtendedGallery
+} from '../server/models/Gallery.ts';
+import type { ArtistCache } from '../server/artist.ts';
+import type { CharacterCache } from '../server/character.ts';
+
+export type RawGallery = z.infer<typeof ZRawGallery>;
+export type BaseGallery = z.infer<typeof ZBaseGallery>;
+export type ExtendedGallery = z.infer<typeof ZExtendedGallery>;
+export type Gallery = z.infer<typeof FullGallery>;
+export type Character = z.infer<typeof FullCharacter>;
+export type BaseArtist = z.infer<typeof ZBaseArtist>;
+export type Artist = z.infer<typeof ZArtist>;
+export type ArtPiece = z.infer<typeof FullArtPiece>;
+export type BaseArtPiece = z.infer<typeof ZBaseArtPiece>;
+export type Picture = z.infer<typeof ZPicture>;
+export type Image = z.infer<typeof ZImage>;
+export type Source = z.infer<typeof ZSource>;
+export type CharacterRef = ArtPiece['characters'][number];
+
+export interface NormalizedCharacter {
+	name: string;
+	from: string | null;
+	info: Character | null;
+}
+export function normalizeCharacter(
+	ref: CharacterRef,
+	characters?: CharacterCache
+): NormalizedCharacter;
+export function normalizeCharacter(
+	ref: Array<CharacterRef>,
+	characters?: CharacterCache
+): Array<NormalizedCharacter>;
+export function normalizeCharacter(
+	ref: CharacterRef | Array<CharacterRef>,
+	characters?: CharacterCache
+): NormalizedCharacter | Array<NormalizedCharacter> {
+	if (Array.isArray(ref)) {
+		return ref.map((ch) => normalizeCharacter(ch, characters));
+	}
+	if (typeof ref === 'string') {
+		return { name: ref, from: null, info: characters?.[ref] ?? null };
+	}
+	return { ...ref, info: null };
+}
+
+export interface NormalizedArtist {
+	name: string;
+	anonymous: boolean;
+	info: Artist | null;
+}
+function normalizeSingleArtist(
+	a: string | { name: string; anonymous: boolean },
+	artists?: ArtistCache
+): NormalizedArtist {
+	const name = typeof a === 'string' ? a : a.name;
+	const foundArtist = artists?.[name] ?? null;
+
+	return {
+		name,
+		anonymous: typeof a === 'string' ? false : a.anonymous,
+		info: foundArtist
+	};
+}
+
+export function normalizeArtist(
+	as: ArtPiece['artist'],
+	artists?: ArtistCache
+): Array<NormalizedArtist> {
+	if (!as) {
+		return [];
+	}
+
+	if (!Array.isArray(as)) {
+		return [normalizeSingleArtist(as, artists)];
+	}
+	return as.map((a) => normalizeSingleArtist(a, artists));
+}
+
+export function no4K(image: Image): Image {
+	const sources = Object.entries(image.sources).reduce(
+		(prev, [k, sources]) => ({ ...prev, [k]: sources.filter((source) => source.w < 3840) }),
+		{} as Image['sources']
+	);
+	const [, best] = bestSource(sources);
+	return {
+		...image,
+		fallback: best,
+		sources: sources
+	};
+}
+
+export function onlyHighRes(image: Image): Image {
+	const [key, best] = bestSource(image.sources);
+	return {
+		...image,
+		fallback: best,
+		sources: {
+			[key]: [best]
+		}
+	};
+}
+
+function bestSource(sources: Image['sources']): [string, z.infer<typeof ZSource>] {
+	const [key, bestSourceType] = sources.webp ? ['webp', sources.webp] : Object.entries(sources)[0];
+	const bestImage = bestSourceType.reduce((p, v) => (v.w > p.max ? { max: v.w, source: v } : p), {
+		max: 0,
+		source: null as Image['sources'][string][number] | null
+	});
+	if (bestImage.source === null) {
+		throw new Error('Could not find any sources?');
+	}
+	return [key, bestImage.source];
+}
+
+export type ResourceRef =
+	| { type: 'character'; resource: NormalizedCharacter }
+	| { type: 'artist'; resource: NormalizedArtist }
+	| { type: 'tag'; resource: string }
+	| { type: 'piece'; resource: ArtPiece }
+	| { type: undefined; resource: undefined };

package/src/lib/util/artistcontext.svelte.ts

@@ -0,0 +1,25 @@
+import { getContext, setContext } from 'svelte';
+import { normalizeArtist, type ArtPiece, type NormalizedArtist } from './art.ts';
+import type { ArtistCache } from '../server/index.ts';
+
+const key = Symbol();
+
+export function useArtistsContext(artists: ArtistCache) {
+	setContext(key, artists);
+	$effect(() => {
+		setContext(key, artists);
+	});
+}
+
+export function useArtists(): ArtistCache {
+	return getContext(key);
+}
+
+export function useArtist(piece: null): null;
+export function useArtist(piece: ArtPiece): Array<NormalizedArtist>;
+export function useArtist(name: string): Array<NormalizedArtist>;
+export function useArtist(piece: string | ArtPiece | null): Array<NormalizedArtist> | null {
+	const allArtists = useArtists();
+	if (!piece) return null;
+	return normalizeArtist(typeof piece === 'string' ? piece : piece.artist, allArtists);
+}

package/src/lib/util/charactercontext.svelte.ts

@@ -0,0 +1,15 @@
+import { getContext, setContext } from 'svelte';
+import type { CharacterCache } from '../server/character.ts';
+
+const key = Symbol();
+
+export function useCharacterContext(characters: CharacterCache) {
+	setContext(key, characters);
+	$effect(() => {
+		setContext(key, characters);
+	});
+}
+
+export function useCharacters(): CharacterCache {
+	return getContext(key);
+}

package/src/lib/util/date.ts

@@ -0,0 +1,7 @@
+export function formatDate(d: Date | string) {
+	if (typeof d === 'string') {
+		d = new Date(d);
+	}
+
+	return d.toLocaleDateString();
+}

package/src/lib/util/index.ts

@@ -0,0 +1,29 @@
+export { no4K, normalizeArtist, normalizeCharacter, onlyHighRes } from './art.ts';
+export type {
+	ArtPiece,
+	Artist,
+	Character,
+	CharacterRef,
+	Gallery,
+	RawGallery,
+	Image,
+	NormalizedArtist,
+	Picture,
+	Source,
+	BaseArtist,
+	BaseArtPiece,
+	BaseGallery,
+	ExtendedGallery,
+	NormalizedCharacter,
+	ResourceRef
+} from './art.ts';
+export { executeSearch } from './search.ts';
+export { useArtist, useArtists, useArtistsContext } from './artistcontext.svelte.ts';
+export { useCharacterContext, useCharacters } from './charactercontext.svelte.ts';
+export { formatDate } from './date.ts';
+export { markdown } from './markdown.ts';
+export { smoothScroll } from './smoothscroll.ts';
+export { setLibraryConfig, type LibraryConfig } from './phosart_config.svelte.ts';
+export { asRecord, multiRecordBy, deduplicateBy } from './util.ts';
+export { asTree, pathView } from './tree.ts';
+export type { FolderElement, GalleryElement, GalleryTree, TreeElement } from './tree.ts';

package/src/lib/util/markdown.ts

@@ -0,0 +1,17 @@
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkRehype from 'remark-rehype';
+import rehypeSanitize from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+
+export function markdown(text: string): string {
+	return unified()
+		.use(remarkParse)
+		.use(remarkGfm)
+		.use(remarkRehype)
+		.use(rehypeSanitize)
+		.use(rehypeStringify)
+		.processSync(text)
+		.toString();
+}