sitero 0.0.1

package/dist/src/core/server/seeders/seed.js

@@ -0,0 +1,22 @@
+import { adminSeeder } from './admin/seeder.js';
+import { configSeeder } from './config/seeder.js';
+import { folderSeeder } from './folder/seeder.js';
+import { pageSeeder } from './page/seeder.js';
+import { topicSeeder } from './topic/seeder.js';
+
+async function seed({
+  prisma,
+  locales,
+  admins,
+  pages,
+  topics,
+  configs
+}) {
+  await adminSeeder({ prisma, locales, admins }).seed();
+  await folderSeeder({ prisma }).seed();
+  await pageSeeder({ prisma, locales, pages }).seed();
+  await topicSeeder({ prisma, locales, topics }).seed();
+  await configSeeder({ prisma, locales, configs }).seed();
+}
+
+export { seed };

package/dist/src/core/server/seeders/topic/seeder.js

@@ -0,0 +1,47 @@
+import '../../../domain/resources/admin/constants.js';
+import { POST_TYPES } from '../../../domain/resources/post/props.js';
+
+function topicSeeder({
+  prisma,
+  topics: staticTopics,
+  locales
+}) {
+  async function checkExistence(slug) {
+    const found = await prisma.post.findFirst({
+      where: { type: POST_TYPES.TOPIC, slug },
+      select: { id: true }
+    });
+    return found ? true : false;
+  }
+  async function seed() {
+    const topics = Object.entries(staticTopics).map(([slug, data]) => ({
+      slug,
+      ...data
+    }));
+    for (const [i, item] of topics.entries()) {
+      const exists = await checkExistence(item.slug);
+      if (exists) continue;
+      await prisma.post.create({
+        data: {
+          type: POST_TYPES.TOPIC,
+          // states
+          isActive: true,
+          isSlugActive: true,
+          slug: item.slug,
+          isIndexActive: true,
+          index: i + 1,
+          // translation
+          translations: {
+            create: locales.map((locale) => ({
+              locale,
+              title: item.title[locale]
+            }))
+          }
+        }
+      });
+    }
+  }
+  return { seed };
+}
+
+export { topicSeeder };

package/dist/src/core/server/server-error.js

@@ -0,0 +1,35 @@
+class ServerError extends Error {
+  i18nKey;
+  statusCode;
+  constructor({
+    message,
+    i18nKey,
+    statusCode
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    if (i18nKey) this.i18nKey = i18nKey;
+    if (statusCode) this.statusCode = statusCode;
+  }
+  /** 401 Unauthorized */
+  static unauthorized() {
+    return new ServerError({ i18nKey: "error.unauthorized", statusCode: 401 });
+  }
+  /** 403 Forbidden */
+  static forbidden() {
+    return new ServerError({ i18nKey: "error.forbidden", statusCode: 403 });
+  }
+  /** 404 Not found */
+  static notFound() {
+    return new ServerError({ i18nKey: "error.not-found", statusCode: 404 });
+  }
+  /** 500 Internal Server Error */
+  static internalServerError() {
+    return new ServerError({
+      i18nKey: "error.internal-server-error",
+      statusCode: 500
+    });
+  }
+}
+
+export { ServerError };

package/dist/src/shared/blob-file/classify-file-type.js

@@ -0,0 +1,27 @@
+import { lookup } from 'mime-types';
+import { FILE_TYPES } from '../../core/domain/resources/file/props.js';
+
+const ARCHIVE_MIME = /* @__PURE__ */ new Set([
+  "application/zip",
+  "application/x-rar-compressed",
+  "application/x-7z-compressed",
+  "application/gzip",
+  "application/x-tar"
+]);
+const classifyFileType = (mimeType, extension) => {
+  if (!mimeType && extension) {
+    mimeType = lookup(extension) || void 0;
+  }
+  if (!mimeType) return FILE_TYPES.OTHER;
+  if (mimeType.startsWith("image/")) return FILE_TYPES.IMAGE;
+  if (mimeType.startsWith("video/")) return FILE_TYPES.VIDEO;
+  if (mimeType.startsWith("audio/")) return FILE_TYPES.AUDIO;
+  if (ARCHIVE_MIME.has(mimeType)) return FILE_TYPES.ARCHIVE;
+  if (mimeType.startsWith("text/") || mimeType === "application/pdf" || mimeType === "application/json" || mimeType === "application/xml") {
+    return FILE_TYPES.DOCUMENT;
+  }
+  if (mimeType.startsWith("application/")) return FILE_TYPES.DOCUMENT;
+  return FILE_TYPES.OTHER;
+};
+
+export { classifyFileType };

package/dist/src/shared/blob-file/format-file-size.js

@@ -0,0 +1,13 @@
+const formatFileSize = (size, decimals = 2) => {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = size;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  const display = unitIndex === 0 ? value.toString() : value.toFixed(decimals);
+  return `${display} ${units[unitIndex]}`;
+};
+
+export { formatFileSize };

package/dist/src/shared/blob-file/get-media-info/get-audio-info.js

@@ -0,0 +1,26 @@
+function getAudioInfo(file) {
+  return new Promise((resolve, reject) => {
+    const audio = document.createElement("audio");
+    const objectUrl = URL.createObjectURL(file);
+    audio.preload = "metadata";
+    const cleanup = () => {
+      audio.removeEventListener("loadedmetadata", onLoadedMetadata);
+      audio.removeEventListener("error", onError);
+      URL.revokeObjectURL(objectUrl);
+    };
+    const onLoadedMetadata = () => {
+      const duration = audio.duration;
+      cleanup();
+      resolve({ duration });
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Failed to load audio metadata."));
+    };
+    audio.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    audio.addEventListener("error", onError, { once: true });
+    audio.src = objectUrl;
+  });
+}
+
+export { getAudioInfo };

package/dist/src/shared/blob-file/get-media-info/get-image-info.js

@@ -0,0 +1,26 @@
+function getImageInfo(file) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const objectUrl = URL.createObjectURL(file);
+    const cleanup = () => {
+      img.removeEventListener("load", onLoad);
+      img.removeEventListener("error", onError);
+      URL.revokeObjectURL(objectUrl);
+    };
+    const onLoad = () => {
+      const width = img.naturalWidth;
+      const height = img.naturalHeight;
+      cleanup();
+      resolve({ width, height });
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Failed to load image for size detection."));
+    };
+    img.addEventListener("load", onLoad, { once: true });
+    img.addEventListener("error", onError, { once: true });
+    img.src = objectUrl;
+  });
+}
+
+export { getImageInfo };

package/dist/src/shared/blob-file/get-media-info/get-media-info.js

@@ -0,0 +1,31 @@
+import { getAudioInfo } from './get-audio-info.js';
+import { getImageInfo } from './get-image-info.js';
+import { getVideoInfo } from './get-video-info.js';
+
+const IMAGE_EXT = /\.(jpe?g|png|gif|webp|bmp|avif)$/i;
+const VIDEO_EXT = /\.(mp4|webm|mov|mkv)$/i;
+const AUDIO_EXT = /\.(mp3|wav|ogg|m4a)$/i;
+const getMediaInfo = async (file) => {
+  const fallback = { width: null, height: null, duration: null };
+  const mime = file.type || "";
+  const name = file instanceof File ? file.name.toLowerCase() : "";
+  try {
+    if (mime.startsWith("image/") || IMAGE_EXT.test(name)) {
+      const { width, height } = await getImageInfo(file);
+      return { width, height, duration: null };
+    }
+    if (mime.startsWith("video/") || VIDEO_EXT.test(name)) {
+      const { width, height, duration } = await getVideoInfo(file);
+      return { width, height, duration };
+    }
+    if (mime.startsWith("audio/") || AUDIO_EXT.test(name)) {
+      const { duration } = await getAudioInfo(file);
+      return { width: null, height: null, duration };
+    }
+    return fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+export { getMediaInfo };

package/dist/src/shared/blob-file/get-media-info/get-video-info.js

@@ -0,0 +1,31 @@
+function getVideoInfo(file) {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    const objectUrl = URL.createObjectURL(file);
+    video.preload = "metadata";
+    const cleanup = () => {
+      video.removeEventListener("loadedmetadata", onLoadedMetadata);
+      video.removeEventListener("error", onError);
+      video.src = "";
+      URL.revokeObjectURL(objectUrl);
+    };
+    const onLoadedMetadata = () => {
+      const info = {
+        width: video.videoWidth,
+        height: video.videoHeight,
+        duration: video.duration
+      };
+      cleanup();
+      resolve(info);
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("Failed to load video metadata."));
+    };
+    video.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    video.addEventListener("error", onError, { once: true });
+    video.src = objectUrl;
+  });
+}
+
+export { getVideoInfo };

package/dist/src/shared/blob-file/mime-to-extension.js

@@ -0,0 +1,8 @@
+import { extension } from 'mime-types';
+
+const mimeToExtension = (mimeType) => {
+  if (!mimeType) return "unknown";
+  return (extension(mimeType) || "unknown").toLowerCase();
+};
+
+export { mimeToExtension };

package/dist/src/shared/form/normalizers/datetime-to-db.js

@@ -0,0 +1,8 @@
+const datetimeToDb = (date) => {
+  if (date == null) return null;
+  const d = typeof date === "string" ? new Date(date) : date;
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString();
+};
+
+export { datetimeToDb };

package/dist/src/shared/form/normalizers/datetime-to-ui.js

@@ -0,0 +1,13 @@
+const datetimeToUi = (date) => {
+  if (date == null) return null;
+  const d = typeof date === "string" ? new Date(date) : date;
+  if (Number.isNaN(d.getTime())) return null;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day}T${hours}:${minutes}`;
+};
+
+export { datetimeToUi };

package/dist/src/shared/form/normalizers/json-array-to-db.js

@@ -0,0 +1,17 @@
+const jsonArrayToDb = (data) => {
+  if (typeof data !== "string" || data.trim() === "") {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) return parsed;
+    if (typeof parsed === "object" && parsed !== null) {
+      return [parsed];
+    }
+    return [];
+  } catch {
+    throw new Error("Invalid JSON");
+  }
+};
+
+export { jsonArrayToDb };

package/dist/src/shared/form/normalizers/json-array-to-ui.js

@@ -0,0 +1,9 @@
+const jsonArrayToUi = (data) => {
+  try {
+    return JSON.stringify(data ?? []);
+  } catch {
+    return "[]";
+  }
+};
+
+export { jsonArrayToUi };

package/dist/src/shared/list-items.js

@@ -0,0 +1,3 @@
+const DO_NOT_FETCH_KEY = "do-not-fetch";
+
+export { DO_NOT_FETCH_KEY };

package/dist/src/shared/result/result.js

@@ -0,0 +1,26 @@
+function success({
+  message,
+  data,
+  meta
+}) {
+  return {
+    success: true,
+    ...message !== void 0 ? { message } : {},
+    ...data !== void 0 ? { data } : {},
+    ...meta !== void 0 ? { meta } : {}
+  };
+}
+function error({ message, errors, code }) {
+  return {
+    success: false,
+    ...message !== void 0 ? { message } : {},
+    ...errors !== void 0 ? { errors } : {},
+    ...code !== void 0 ? { code } : {}
+  };
+}
+const result = {
+  success,
+  error
+};
+
+export { result };

package/dist/src/shared/seo-metadata.js

@@ -0,0 +1,22 @@
+const OG_TYPE_ARRAY = [
+  "article",
+  "book",
+  "music.song",
+  "music.album",
+  "music.playlist",
+  "music.radio_station",
+  "profile",
+  "website",
+  "video.tv_show",
+  "video.other",
+  "video.movie",
+  "video.episode"
+];
+const TWITTER_CARD_ARRAY = [
+  "summary",
+  "summary_large_image",
+  "player",
+  "app"
+];
+
+export { OG_TYPE_ARRAY, TWITTER_CARD_ARRAY };

package/dist/src/shared/translation/create-build-translations.js

@@ -0,0 +1,11 @@
+function createBuildTranslations({ locales }) {
+  return function buildTranslations(fields) {
+    const entries = fields.map((f) => [f.key, f.value]);
+    return locales.map((locale) => ({
+      locale,
+      ...Object.fromEntries(entries)
+    }));
+  };
+}
+
+export { createBuildTranslations };

package/dist/src/shared/translation/find-translation.js

@@ -0,0 +1,13 @@
+function findTranslation(translations, locale, defaultValue) {
+  const fallback = translations?.[0];
+  const found = translations?.find((t) => t.locale === locale) ?? fallback;
+  if (!found) return { locale: locale ?? "" };
+  const result = { ...found };
+  for (const key of Object.keys(result)) {
+    if (key === "locale") continue;
+    if (result[key] == null) result[key] = defaultValue;
+  }
+  return result;
+}
+
+export { findTranslation };

package/dist/src/shared/units.js

@@ -0,0 +1,10 @@
+const SIZE = {
+  BYTE: 1,
+  KB: 1024,
+  MB: 1024 ** 2,
+  GB: 1024 ** 3,
+  TB: 1024 ** 4,
+  PB: 1024 ** 5
+};
+
+export { SIZE };

package/dist/src/shared/utils/cn.js

@@ -0,0 +1,8 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+const cn = (...inputs) => {
+  return twMerge(clsx(inputs));
+};
+
+export { cn };

package/dist/src/shared/utils/debounce.js

@@ -0,0 +1,14 @@
+const debounce = (fn, delay = 100) => {
+  let timer;
+  const debouncedFn = (...args) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), delay);
+  };
+  debouncedFn.clear = () => {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+  };
+  return debouncedFn;
+};
+
+export { debounce };

package/dist/src/shared/utils/ensure-array.js

@@ -0,0 +1,6 @@
+function ensureArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export { ensureArray };

package/dist/src/shared/utils/join-url.js

@@ -0,0 +1,17 @@
+function joinUrl(...parts) {
+  const filtered = parts.filter(
+    (part) => part !== void 0 && part !== null && part !== ""
+  );
+  if (filtered.length === 0) return "";
+  const segments = filtered.map((part, index) => {
+    if (index === 0) {
+      return part.replace(/\/+$/, "");
+    }
+    return part.replace(/^\/+|\/+$/g, "");
+  });
+  const result = segments.join("/");
+  if (result === "") return "/";
+  return result;
+}
+
+export { joinUrl };

package/dist/src/shared/utils/locale-to-flag-emoji.js

@@ -0,0 +1,7 @@
+function localeToFlagEmoji(locale) {
+  const region = new Intl.Locale(locale).region;
+  if (!region) return null;
+  return region.toUpperCase().replace(/./g, (char) => String.fromCodePoint(127397 + char.charCodeAt(0)));
+}
+
+export { localeToFlagEmoji };

package/dist/src/shared/utils/normalize-slug.js

@@ -0,0 +1,9 @@
+function normalizeSlug(raw) {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return raw;
+  }
+}
+
+export { normalizeSlug };

package/dist/src/shared/utils/parse-positive-int.js

@@ -0,0 +1,10 @@
+function parsePositiveInt(value, defaultValue = 1) {
+  const n = Number(value);
+  const isValid = Number.isInteger(n) && n > 0;
+  return {
+    value: isValid ? n : defaultValue,
+    isValid
+  };
+}
+
+export { parsePositiveInt };

package/dist/src/shared/utils/to-iso-time.js

@@ -0,0 +1,8 @@
+const toIsoTime = (input) => {
+  if (input == null) return void 0;
+  const date = typeof input === "string" ? new Date(input) : input;
+  if (isNaN(date.getTime())) return void 0;
+  return date.toISOString();
+};
+
+export { toIsoTime };

package/dist/src/shared/utils/version.js

@@ -0,0 +1,25 @@
+const BUILD_ID_PATH = ".next/BUILD_ID";
+let cached;
+let hasLoaded = false;
+const createVersion = ({
+  readFileSync,
+  joinPath,
+  rootDir
+}) => ({
+  getBuildId() {
+    if (hasLoaded) return cached;
+    hasLoaded = true;
+    try {
+      cached = readFileSync(joinPath(rootDir, BUILD_ID_PATH), "utf-8").trim();
+    } catch {
+      cached = void 0;
+    }
+    return cached;
+  },
+  append(url) {
+    const buildId = this.getBuildId();
+    return buildId ? `${url}?v=${buildId}` : url;
+  }
+});
+
+export { createVersion };

package/dist/src/web/client/applications/build-pagination.js

@@ -0,0 +1,65 @@
+function buildPagination(input) {
+  const { page, pageSize, total, siblings = 2 } = input;
+  if (pageSize <= 0) {
+    throw new Error("pageSize must be greater than 0");
+  }
+  const totalPages = Math.max(1, Math.ceil(total / pageSize));
+  const safePage = Math.min(Math.max(1, page), totalPages);
+  const canPrev = safePage > 1;
+  const canNext = safePage < totalPages;
+  const items = [];
+  items.push({
+    type: "control",
+    control: "prev",
+    disabled: !canPrev,
+    page: safePage - 1
+  });
+  items.push({
+    type: "page",
+    page: 1,
+    active: safePage === 1
+  });
+  let start = Math.max(2, safePage - siblings);
+  let end = Math.min(totalPages - 1, safePage + siblings);
+  if (safePage - siblings < 2) {
+    end = Math.min(totalPages - 1, end + (2 - (safePage - siblings)));
+  }
+  if (safePage + siblings > totalPages - 1) {
+    start = Math.max(2, start - (safePage + siblings - (totalPages - 1)));
+  }
+  if (start > 2) {
+    items.push({ type: "ellipsis" });
+  }
+  for (let i = start; i <= end; i++) {
+    items.push({
+      type: "page",
+      page: i,
+      active: i === safePage
+    });
+  }
+  if (end < totalPages - 1) {
+    items.push({ type: "ellipsis" });
+  }
+  if (totalPages > 1) {
+    items.push({
+      type: "page",
+      page: totalPages,
+      active: safePage === totalPages
+    });
+  }
+  items.push({
+    type: "control",
+    control: "next",
+    disabled: !canNext,
+    page: safePage + 1
+  });
+  return {
+    page: safePage,
+    totalPages,
+    items,
+    canPrev,
+    canNext
+  };
+}
+
+export { buildPagination };

package/dist/src/web/client/applications/structured-data/build/build-breadcrumb.js

@@ -0,0 +1,30 @@
+function createBuildBreadcrumb({
+  getPageIdentity
+}) {
+  return function buildBreadcrumb(pageIdentity, items) {
+    if (items.length === 0) return void 0;
+    const { locale, breadcrumbId } = pageIdentity;
+    const listItems = items.map((item, index) => {
+      const itemIdentity = getPageIdentity(item.pathname, locale);
+      return {
+        "@type": "ListItem",
+        position: index + 1,
+        name: item.name,
+        item: {
+          "@id": itemIdentity.webpageId,
+          url: itemIdentity.pageUrl,
+          name: item.name
+        }
+      };
+    });
+    return {
+      "@type": "BreadcrumbList",
+      "@id": breadcrumbId,
+      itemListOrder: "ItemListOrderAscending",
+      numberOfItems: listItems.length,
+      itemListElement: listItems
+    };
+  };
+}
+
+export { createBuildBreadcrumb };