website-xp-phone 1.5.0

package/scripts/hoist-dev-blog-local.mjs

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+
+function createProjectPaths(currentWorkingDirectory) {
+  const workspaceRoot = currentWorkingDirectory;
+  return Object.freeze({
+    workspaceRoot,
+    publicBlogAssetsPath: path.resolve(workspaceRoot, "public", "blog-assets"),
+    externalBlogPath: path.resolve(workspaceRoot, "..", "blog", "blog"),
+    viteBinPath: path.resolve(workspaceRoot, "node_modules/vite/bin/vite.js"),
+  });
+}
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function getPathStatsOrNull(targetPath) {
+  if (!pathExists(targetPath)) {
+    return null;
+  }
+  return fs.lstatSync(targetPath);
+}
+
+function isDirectorySymlink(targetPath) {
+  const stats = getPathStatsOrNull(targetPath);
+  return stats ? stats.isSymbolicLink() : false;
+}
+
+function isSymlinkTarget(linkPath, expectedTargetPath) {
+  if (!isDirectorySymlink(linkPath) || !pathExists(expectedTargetPath)) {
+    return false;
+  }
+  return fs.realpathSync(linkPath) === fs.realpathSync(expectedTargetPath);
+}
+
+function unlinkPath(targetPath) {
+  fs.unlinkSync(targetPath);
+}
+
+function createRelativeDirectorySymlink(linkPath, targetPath) {
+  const relativeTarget = path.relative(path.dirname(linkPath), targetPath) || ".";
+  fs.symlinkSync(relativeTarget, linkPath, "dir");
+}
+
+function logWarning(message) {
+  console.warn(`[dev] ${message}`);
+}
+
+function probeInterruptedRunAndCleanup(paths) {
+  if (!pathExists(paths.publicBlogAssetsPath)) {
+    return;
+  }
+
+  if (isSymlinkTarget(paths.publicBlogAssetsPath, paths.externalBlogPath)) {
+    unlinkPath(paths.publicBlogAssetsPath);
+  }
+}
+
+function ensureExternalBlogExists(paths) {
+  if (pathExists(paths.externalBlogPath)) {
+    return true;
+  }
+
+  logWarning("../blog/blog is missing; blog-assets symlink was not created.");
+  return false;
+}
+
+function ensurePublicBlogAssetsPathCanBeLinked(paths) {
+  if (!pathExists(paths.publicBlogAssetsPath)) {
+    return true;
+  }
+
+  if (isDirectorySymlink(paths.publicBlogAssetsPath)) {
+    logWarning("public/blog-assets exists as a symlink to another target; leaving it unchanged.");
+  } else {
+    logWarning("public/blog-assets exists as a real directory; leaving it unchanged.");
+  }
+  return false;
+}
+
+function ensureBlogSymlink(paths) {
+  if (!ensureExternalBlogExists(paths)) {
+    return;
+  }
+
+  if (!ensurePublicBlogAssetsPathCanBeLinked(paths)) {
+    return;
+  }
+
+  createRelativeDirectorySymlink(paths.publicBlogAssetsPath, paths.externalBlogPath);
+}
+
+function cleanupBlogSymlink(paths) {
+  if (!pathExists(paths.publicBlogAssetsPath)) {
+    return;
+  }
+
+  if (isSymlinkTarget(paths.publicBlogAssetsPath, paths.externalBlogPath)) {
+    unlinkPath(paths.publicBlogAssetsPath);
+  }
+}
+
+function spawnVite(paths) {
+  return spawn(process.execPath, [paths.viteBinPath], {
+    cwd: paths.workspaceRoot,
+    stdio: "inherit",
+    env: process.env,
+  });
+}
+
+function forwardSignalToVite(viteProcess, signalName) {
+  viteProcess.kill(signalName);
+}
+
+function registerProcessHandlers(viteProcess, cleanupHandler) {
+  process.on("exit", cleanupHandler);
+  process.on("SIGINT", () => forwardSignalToVite(viteProcess, "SIGINT"));
+  process.on("SIGTERM", () => forwardSignalToVite(viteProcess, "SIGTERM"));
+}
+
+function registerViteExitHandler(viteProcess, cleanupHandler) {
+  viteProcess.on("exit", (code, signal) => {
+    cleanupHandler();
+
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 0);
+  });
+}
+
+function run() {
+  const paths = createProjectPaths(process.cwd());
+  probeInterruptedRunAndCleanup(paths);
+  ensureBlogSymlink(paths);
+
+  const cleanupHandler = () => cleanupBlogSymlink(paths);
+  const viteProcess = spawnVite(paths);
+
+  registerProcessHandlers(viteProcess, cleanupHandler);
+  registerViteExitHandler(viteProcess, cleanupHandler);
+}
+
+run();

package/scripts/music-schema.mjs

@@ -0,0 +1,56 @@
+const MUSIC_GROUP_NAME = "akinevz";
+const MUSIC_GROUP_URL = "https://akinevz.com";
+const MUSIC_GROUP_DESCRIPTION =
+    "Independent sound designer, music creator, and electronic music artist.";
+const MUSIC_GROUP_ALTERNATE_NAMES = [
+    "KINE",
+    "KALE",
+    "I lied my name isn't actually KINE",
+    "I lied my name isn't actually KALE",
+];
+const MUSIC_GROUP_GENRES = [
+    "Electronic",
+    "Experimental",
+    "Industrial",
+    "Drone",
+    "Glitch",
+];
+const MUSIC_GROUP_SAME_AS = [
+    "https://soundcloud.com/akinevz",
+    "https://youtube.com/@akinevz",
+    "https://x.com/akinevz",
+    "https://github.com/akinevz2",
+];
+const MUSIC_GROUP_PRIMARY_ALIAS = MUSIC_GROUP_ALTERNATE_NAMES[0];
+
+export const serializeJsonLd = (value) =>
+    JSON.stringify(value).replace(/</g, "\\u003c");
+
+export const buildMusicGroupSchema = (tracks = []) => ({
+    "@context": "https://schema.org",
+    "@type": "MusicGroup",
+    name: MUSIC_GROUP_NAME,
+    alternateName: MUSIC_GROUP_ALTERNATE_NAMES,
+    url: MUSIC_GROUP_URL,
+    genre: MUSIC_GROUP_GENRES,
+    description: MUSIC_GROUP_DESCRIPTION,
+    sameAs: MUSIC_GROUP_SAME_AS,
+    track: Array.isArray(tracks)
+        ? tracks
+            .filter(
+                (track) =>
+                    track && typeof track.title === "string" && typeof track.url === "string",
+            )
+            .map((track) => {
+                return {
+                    "@type": "MusicRecording",
+                    name: track.title,
+                    url: track.url,
+                    byArtist: {
+                        "@type": "MusicGroup",
+                        name: MUSIC_GROUP_PRIMARY_ALIAS,
+                    },
+                };
+            })
+        : [],
+});

package/scripts/publish-soundcloud-json.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve, join } from "node:path";
+import { copyFileSync, existsSync } from "node:fs";
+import { withGitWorktree } from "./git-worktree-helper.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Paths
+const BLOG_DIRSTRING = "blog";
+const WEBSITE_DIR = resolve(__dirname, "..");
+const BLOG_DIR = resolve(WEBSITE_DIR, BLOG_DIRSTRING);
+const SOUNDCloudJSON_PATH = resolve(WEBSITE_DIR, "public", "soundcloud.json");
+const BLOG_SOUNDCloudJSON_PATH = resolve(BLOG_DIR, "soundcloud.json");
+
+console.log("🚀 Publishing soundcloud.json to GitHub...");
+
+// Step 1: Ensure soundcloud.json exists
+if (!existsSync(SOUNDCloudJSON_PATH)) {
+    console.error("❌ soundcloud.json not found. Run 'npm run generate:music' first.");
+    process.exit(1);
+}
+
+// Step 2: Copy to blog directory
+withGitWorktree(BLOG_DIRSTRING, "blog-posts", async (worktreeDir) => {
+    console.log("📋 Copying soundcloud.json to blog worktree...");
+    copyFileSync(SOUNDCloudJSON_PATH, BLOG_SOUNDCloudJSON_PATH);
+});
+
+console.log("✅ Successfully published soundcloud.json to GitHub!");

package/scripts/sync-music-links-from-worktree.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+// Fetches music-links.json from the blog-posts branch on GitHub CDN,
+// validates its schema in memory, and reports the result.
+// Does not write to disk — the file is consumed at runtime by MusicContent.tsx.
+
+const MUSIC_LINKS_URL =
+  "https://raw.githubusercontent.com/akinevz2/frontend/blog-posts/music-links.json";
+
+const isFavouriteLink = (value) =>
+  value !== null &&
+  typeof value === "object" &&
+  typeof value.title === "string" &&
+  typeof value.url === "string";
+
+const response = await fetch(MUSIC_LINKS_URL);
+if (!response.ok) {
+  process.stderr.write(`Failed to fetch ${MUSIC_LINKS_URL}: HTTP ${response.status}\n`);
+  process.exit(1);
+}
+
+const payload = await response.json();
+if (!Array.isArray(payload)) {
+  process.stderr.write(`Invalid music-links.json: expected a JSON array\n`);
+  process.exit(1);
+}
+
+const valid = payload.filter(isFavouriteLink);
+const invalid = payload.length - valid.length;
+
+process.stdout.write(
+  `music-links.json OK — ${valid.length} valid link(s)${invalid > 0 ? `, ${invalid} skipped (missing title/url)` : ""}\n`,
+);