@phtngyn/cms 0.2.0-beta.7 → 0.3.0

package/src/Links-CJYyy7rC.js

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+//#region ../model/src/Links.ts
+const LinkDocumentId = Schema.String.check(Schema.isUUID());
+/** A URL or a stable page identity with the route last shown to its author. */
+const LinkTarget = Schema.Union([Schema.Struct({
+	kind: Schema.Literal("url"),
+	href: Schema.String
+}), Schema.Struct({
+	kind: Schema.Literal("document"),
+	documentId: LinkDocumentId,
+	path: Schema.String
+})]);
+function safeLinkHref(href) {
+	if (!href || href !== href.trim() || /\s|\\/u.test(href)) return false;
+	if (href.startsWith("/") && !href.startsWith("//")) return true;
+	if (href.startsWith("#")) return true;
+	if (/^mailto:[^\s@]+@[^\s@]+$/iu.test(href)) return true;
+	if (/^tel:[+\d][\d -]*$/u.test(href)) return true;
+	if (!/^https?:\/\//iu.test(href)) return false;
+	try {
+		const url = new URL(href);
+		return (url.protocol === "http:" || url.protocol === "https:") && !!url.hostname && !url.username && !url.password;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { safeLinkHref as n, LinkTarget as t };

package/src/Links-Dx1yOni8.d.ts

@@ -0,0 +1,28 @@
+import "./Media-BQ0uL4w7.js";
+import { Schema } from "effect";
+//#region ../model/src/Image.d.ts
+/** A framed image authored in a collection field or block property. */
+declare const AuthoredImage: Schema.Struct<{
+  readonly focalX: Schema.optionalKey<Schema.Int>;
+  readonly focalY: Schema.optionalKey<Schema.Int>;
+  readonly zoom: Schema.optionalKey<Schema.Finite>;
+  readonly kind: Schema.Literal<"image">;
+  readonly mediaId: Schema.String;
+  readonly alt: Schema.optionalKey<Schema.String>;
+  readonly frame: Schema.optionalKey<Schema.Literals<readonly ["square", "wide"]>>;
+}>;
+type AuthoredImage = typeof AuthoredImage.Type;
+//#endregion
+//#region ../model/src/Links.d.ts
+/** A URL or a stable page identity with the route last shown to its author. */
+declare const LinkTarget: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"url">;
+  readonly href: Schema.String;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"document">;
+  readonly documentId: Schema.String;
+  readonly path: Schema.String;
+}>]>;
+type LinkTarget = typeof LinkTarget.Type;
+//#endregion
+export { AuthoredImage as n, LinkTarget as t };

package/src/Locales-Ch7a5xuA.js

@@ -0,0 +1,67 @@
+import { o as languageName, s as localeDirection, t as canonicalLocale } from "./I18n-Ckf9h0rC.js";
+import { Schema } from "effect";
+//#region ../model/src/Locales.ts
+function localeIssue(code) {
+	const canonical = canonicalLocale(code);
+	if (!canonical) return `Locale "${code}" must be a valid BCP 47 language code.`;
+	if (canonical !== code) return `Locale "${code}" must use its canonical base code "${canonical}" without extensions.`;
+}
+/** Durable language identities use one canonical BCP 47 base code everywhere. */
+const Locale = Schema.NonEmptyString.check(Schema.makeFilter(localeIssue));
+/** Reject invalid dictionary keys instead of discarding them as unmatched record patterns. */
+function localizedValues(value) {
+	return Schema.Record(Schema.String, value).check(Schema.makeFilter((values) => Object.keys(values).flatMap((code) => {
+		const issue = localeIssue(code);
+		return issue ? [{
+			path: [code],
+			issue
+		}] : [];
+	})));
+}
+const LocaleDefinition = Schema.Struct({
+	code: Locale,
+	label: Schema.optionalKey(Schema.NonEmptyString),
+	dir: Schema.optionalKey(Schema.Literals(["ltr", "rtl"]))
+});
+/** Serializable site-owned languages and their shared URL-prefix policy. */
+const LocaleConfiguration = Schema.Struct({
+	defaultLocale: Locale,
+	supported: Schema.Array(LocaleDefinition),
+	prefixDefault: Schema.Boolean
+}).check(Schema.makeFilter((configuration) => {
+	const issues = [];
+	const codes = configuration.supported.map((locale) => locale.code);
+	if (codes.length === 0) issues.push({
+		path: ["supported"],
+		issue: "At least one supported locale is required."
+	});
+	if (!codes.includes(configuration.defaultLocale)) issues.push({
+		path: ["defaultLocale"],
+		issue: "The default locale must be configured."
+	});
+	if (new Set(codes).size !== codes.length) issues.push({
+		path: ["supported"],
+		issue: "Supported locales must be unique."
+	});
+	return issues;
+}));
+/** Validate canonical identities once; omitted prefixDefault keeps the default language unprefixed. */
+function defineLocales(configuration) {
+	const complete = {
+		...configuration,
+		prefixDefault: configuration.prefixDefault ?? false
+	};
+	Schema.decodeSync(LocaleConfiguration)(complete);
+	return complete;
+}
+/** Resolve presentation metadata without matching a different content language. */
+function resolveLocale(code, configuration, displayLocale = code) {
+	const configured = configuration?.supported.find((locale) => locale.code === code);
+	return {
+		code,
+		label: configured?.label ?? languageName(code, displayLocale),
+		dir: configured?.dir ?? localeDirection(code)
+	};
+}
+//#endregion
+export { resolveLocale as a, localizedValues as i, LocaleConfiguration as n, defineLocales as r, Locale as t };

package/src/Locales-jwbmJaOp.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+//#region ../model/src/Locales.d.ts
+/** Durable language identities use one canonical BCP 47 base code everywhere. */
+declare const Locale: Schema.NonEmptyString;
+type Locale = typeof Locale.Type;
+declare const LocaleDefinition: Schema.Struct<{
+  readonly code: Schema.NonEmptyString;
+  readonly label: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly dir: Schema.optionalKey<Schema.Literals<readonly ["ltr", "rtl"]>>;
+}>;
+interface LocaleDefinition extends Schema.Schema.Type<typeof LocaleDefinition> {}
+/** Serializable site-owned languages and their shared URL-prefix policy. */
+declare const LocaleConfiguration: Schema.Struct<{
+  readonly defaultLocale: Schema.NonEmptyString;
+  readonly supported: Schema.$Array<Schema.Struct<{
+    readonly code: Schema.NonEmptyString;
+    readonly label: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly dir: Schema.optionalKey<Schema.Literals<readonly ["ltr", "rtl"]>>;
+  }>>;
+  readonly prefixDefault: Schema.Boolean;
+}>;
+interface LocaleConfiguration extends Schema.Schema.Type<typeof LocaleConfiguration> {}
+/** The enabled language-code union of a literal site configuration. */
+type ConfiguredLocale<Configuration extends LocaleConfiguration> = Configuration['supported'][number]['code'];
+/** Validate canonical identities once; omitted prefixDefault keeps the default language unprefixed. */
+declare function defineLocales<const Supported extends ReadonlyArray<LocaleDefinition>>(configuration: {
+  readonly defaultLocale: NoInfer<Supported[number]['code']>;
+  readonly supported: Supported;
+  readonly prefixDefault?: boolean;
+}): {
+  prefixDefault: boolean;
+  defaultLocale: NoInfer<Supported[number]["code"]>;
+  supported: Supported;
+};
+interface ResolvedLocaleDefinition {
+  readonly code: string;
+  readonly label: string;
+  readonly dir: 'ltr' | 'rtl';
+}
+/** Resolve presentation metadata without matching a different content language. */
+declare function resolveLocale(code: string, configuration?: LocaleConfiguration, displayLocale?: string): ResolvedLocaleDefinition;
+//#endregion
+export { ResolvedLocaleDefinition as a, LocaleDefinition as i, Locale as n, defineLocales as o, LocaleConfiguration as r, resolveLocale as s, ConfiguredLocale as t };

package/src/Locales.d.ts

@@ -0,0 +1,3 @@
+import { a as ResolvedLocaleDefinition, i as LocaleDefinition, n as Locale, o as defineLocales, r as LocaleConfiguration, s as resolveLocale, t as ConfiguredLocale } from "./Locales-jwbmJaOp.js";
+import { a as unlocalizedPath, i as switchLocalePath, n as localeFromPath, r as localePath, t as canonicalLocalePath } from "./Routes-DM1rRp3r.js";
+export { type ConfiguredLocale, Locale, LocaleConfiguration, type LocaleDefinition, type ResolvedLocaleDefinition, canonicalLocalePath, defineLocales, localeFromPath, localePath, resolveLocale, switchLocalePath, unlocalizedPath };

package/src/Locales.js

@@ -0,0 +1,3 @@
+import { a as resolveLocale, n as LocaleConfiguration, r as defineLocales, t as Locale } from "./Locales-Ch7a5xuA.js";
+import { i as localePath, o as switchLocalePath, r as localeFromPath, s as unlocalizedPath, t as canonicalLocalePath } from "./Routes-BaZvm2LE.js";
+export { Locale, LocaleConfiguration, canonicalLocalePath, defineLocales, localeFromPath, localePath, resolveLocale, switchLocalePath, unlocalizedPath };

package/src/Media-BQ0uL4w7.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+//#region ../model/src/Media.d.ts
+declare const MediaId: Schema.brand<Schema.String, "MediaId">;
+type MediaId = typeof MediaId.Type;
+declare const MediaKind: Schema.Literals<readonly ["image", "video"]>;
+type MediaKind = typeof MediaKind.Type;
+/** A structured field's stable reference to an asset in the media library. */
+declare const MediaSelection: Schema.Struct<{
+  readonly kind: Schema.Literal<"media">;
+  readonly mediaId: Schema.String;
+  readonly mediaKind: Schema.Literals<readonly ["image", "video"]>;
+}>;
+type MediaSelection = typeof MediaSelection.Type;
+//#endregion
+export { MediaKind as n, MediaSelection as r, MediaId as t };

package/src/Media-DSyvd14o.js

@@ -0,0 +1,87 @@
+import { Schema } from "effect";
+//#region ../model/src/Media.ts
+function safePath(value, allowEmpty) {
+	if (!value) return allowEmpty;
+	if (value !== value.trim() || value.startsWith("/") || value.endsWith("/")) return false;
+	return value.split("/").every((segment) => safeSegment(segment));
+}
+function safeSegment(value) {
+	if (!value || value === "." || value === "..") return false;
+	return !Array.from(value).some((character) => {
+		const code = character.codePointAt(0);
+		return character === "\\" || code !== void 0 && (code <= 31 || code === 127);
+	});
+}
+const MediaId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("MediaId"));
+const MediaName = Schema.String.check(Schema.isMaxLength(255), Schema.makeFilter((value) => safeSegment(value) && !value.includes("/"), { expected: "a safe media name" }));
+const MediaFolder = Schema.String.check(Schema.isMaxLength(512), Schema.makeFilter((value) => safePath(value, true), { expected: "a safe media folder" }));
+const MediaMimeType = Schema.Literals([
+	"image/avif",
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/webp",
+	"video/mp4",
+	"video/webm",
+	"application/pdf"
+]);
+/** Source bound for the memory-backed image transformer. Videos use the installation upload limit. */
+const maxImageSourceBytes = 20971520;
+function mediaUploadByteLimit(mimeType, maxUploadBytes) {
+	return mimeType.startsWith("image/") ? Math.min(maxUploadBytes, maxImageSourceBytes) : maxUploadBytes;
+}
+const MediaLibraryKind = Schema.Literals([
+	"image",
+	"video",
+	"document"
+]);
+const MediaSort = Schema.Literals([
+	"newest",
+	"name",
+	"size"
+]);
+const MediaFolderSummary = Schema.Struct({
+	folder: MediaFolder,
+	count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+const MediaKind = Schema.Literals(["image", "video"]);
+/** A structured field's stable reference to an asset in the media library. */
+const MediaSelection = Schema.Struct({
+	kind: Schema.Literal("media"),
+	mediaId: Schema.String.check(Schema.isUUID()),
+	mediaKind: MediaKind
+});
+const MediaLayout = Schema.Literals([
+	"natural",
+	"content",
+	"full"
+]);
+function mediaPath(id) {
+	return `/_cms/media/${id}`;
+}
+const MediaChecksum = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u));
+const MediaAsset = Schema.Struct({
+	id: MediaId,
+	name: MediaName,
+	folder: MediaFolder,
+	mimeType: MediaMimeType,
+	byteSize: Schema.Int.check(Schema.isGreaterThan(0)),
+	sha256: MediaChecksum,
+	url: Schema.NonEmptyString,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const MediaUpload = Schema.Struct({
+	name: MediaName,
+	folder: MediaFolder,
+	declaredMimeType: MediaMimeType,
+	declaredByteSize: Schema.Int.check(Schema.isGreaterThan(0)),
+	expectedSha256: Schema.optionalKey(MediaChecksum)
+});
+const MediaPage = Schema.Struct({
+	assets: Schema.Array(MediaAsset),
+	folders: Schema.Array(MediaFolder),
+	total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+//#endregion
+export { MediaKind as a, MediaMimeType as c, MediaSort as d, MediaUpload as f, mediaUploadByteLimit as h, MediaId as i, MediaPage as l, mediaPath as m, MediaFolder as n, MediaLayout as o, maxImageSourceBytes as p, MediaFolderSummary as r, MediaLibraryKind as s, MediaAsset as t, MediaSelection as u };

package/src/Module.d.ts

@@ -1,12 +1,4 @@
-import { HookResult } from "@nuxt/schema";
-import { NitroConfig } from "nitropack/types";
 //#region src/Module.d.ts
-declare module '@nuxt/schema' {
-  interface NuxtHooks {
-    'nitro:config': (nitroConfig: NitroConfig) => HookResult;
-  }
-}
-declare const cmsNuxtModule: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
+declare const _default: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
 //#endregion
-export { cmsNuxtModule as default };
-//# sourceMappingURL=Module.d.ts.map
+export { _default as default };