create-portfoliable 1.0.3

package/templates/public/api/README.md

@@ -0,0 +1,27 @@
+# Protection Unlock Endpoint Examples
+
+Default production flow is now PHP-first for self-hosted deployments.
+
+Use these files:
+
+- `../public/api/unlock-case.php`
+- `../public/api/password.config.example.json`
+- `../public/api/.htaccess`
+- `../scripts/generate-password-hash.mjs`
+
+1. Copy `public/api/password.config.example.json` to `public/api/password.config.json`.
+2. Generate one hash record per protected case id:
+
+```bash
+npm run password:hash -- --case-id mobile-product-launch --password "your-secret"
+```
+
+3. Paste the generated `hash` under `cases.<caseId>.hash`.
+4. Keep `unlockEndpoint: '/api/unlock-case.php'` in `configs/portfoliable.design.config.js`.
+
+Security notes:
+
+- Never store plaintext passwords in markdown case config.
+- Keep `public/api/password.config.json` out of git.
+- Keep direct access blocked via `public/api/.htaccess`.
+- The unlock endpoint should disable caching (`Cache-Control: no-store`).

package/templates/public/api/password.config.example.json

@@ -0,0 +1,16 @@
+{
+  "_comment": "Copy to public/api/password.config.json for self-hosted PHP unlock verification. Keep each case password unique.",
+  "_format": {
+    "description": "Map case id to one password_hash() record.",
+    "algorithm": "password_hash",
+    "recommended": "PASSWORD_ARGON2ID"
+  },
+  "cases": {
+    "mobile-product-launch": {
+      "hash": "$argon2id$v=19$m=65536,t=4,p=1$replace$with-generated-hash"
+    },
+    "mobile-checkout-flow": {
+      "hash": "$argon2id$v=19$m=65536,t=4,p=1$replace$with-generated-hash"
+    }
+  }
+}

package/templates/public/api/password.config.json

@@ -0,0 +1,16 @@
+{
+  "_comment": "Development-only sample. Replace hashes before publishing.",
+  "_format": {
+    "description": "Map case id to one password_hash() record.",
+    "algorithm": "password_hash",
+    "recommended": "PASSWORD_ARGON2ID"
+  },
+  "cases": {
+    "mobile-product-launch": {
+      "hash": "$argon2id$v=19$m=65536,t=4,p=1$Qnl0Y2xRSDVlR0dnWEdjUw$4/FMC0f+ETbZif7hXY5lTvf5qDRMRJCcNHnqvOP86ac"
+    },
+    "mobile-checkout-flow": {
+      "hash": "$2y$12$vlGuw0/Pw75l0JDzSvNhoe4/E2CdByjSunLpz.krX15eqd7y4G316"
+    }
+  }
+}

package/templates/public/api/unlock-case.php

@@ -0,0 +1,56 @@
+<?php
+// File: templates/public/api/unlock-case.php
+// Purpose: Validate per-case passwords server-side for PHP-compatible self-hosting.
+
+declare(strict_types=1);
+
+header('Content-Type: application/json');
+header('Cache-Control: no-store');
+
+if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
+    http_response_code(405);
+    echo json_encode(['ok' => false, 'error' => 'method-not-allowed']);
+    exit;
+}
+
+$rawBody = file_get_contents('php://input');
+$payload = json_decode($rawBody ?: '{}', true);
+
+if (!is_array($payload)) {
+    http_response_code(400);
+    echo json_encode(['ok' => false, 'error' => 'invalid-json']);
+    exit;
+}
+
+$caseId = trim((string)($payload['caseId'] ?? ''));
+$password = (string)($payload['password'] ?? '');
+
+if ($caseId === '' || $password === '') {
+    http_response_code(400);
+    echo json_encode(['ok' => false, 'error' => 'missing-input']);
+    exit;
+}
+
+$configPath = __DIR__ . '/password.config.json';
+if (!is_file($configPath)) {
+    http_response_code(401);
+    echo json_encode(['ok' => false]);
+    exit;
+}
+
+$configRaw = file_get_contents($configPath);
+$config = json_decode($configRaw ?: '{}', true);
+$record = is_array($config) && isset($config['cases'][$caseId]) && is_array($config['cases'][$caseId])
+    ? $config['cases'][$caseId]
+    : null;
+$storedHash = is_array($record) ? (string)($record['hash'] ?? '') : '';
+
+if ($storedHash === '') {
+    http_response_code(401);
+    echo json_encode(['ok' => false]);
+    exit;
+}
+
+$ok = password_verify($password, $storedHash);
+http_response_code($ok ? 200 : 401);
+echo json_encode(['ok' => $ok]);

package/templates/public/portfoliable-logo.svg

@@ -0,0 +1,3 @@
+<svg width="792" height="792" viewBox="0 0 792 792" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M644.404 0C725.919 0 792 66.0809 792 147.596V644.404C792 725.919 725.919 792 644.404 792H374.924C363.878 792 354.924 783.046 354.924 772V590.825C354.924 579.78 363.878 570.825 374.924 570.825H480.214C530.713 570.825 573.223 561.556 607.742 543.019C642.261 524.268 668.363 498.591 686.049 465.99C703.734 433.389 712.576 396.1 712.576 354.124C712.576 312.574 703.734 275.498 686.049 242.897C668.576 210.083 642.686 184.301 608.381 165.55C574.288 146.799 532.098 137.423 481.812 137.423H284.58C257.941 137.423 236.346 159.018 236.346 185.657V772C236.346 783.046 227.391 792 216.346 792H147.596C66.0809 792 0 725.919 0 644.404V147.596C0 66.0809 66.0809 0 147.596 0H644.404ZM463.595 236.505C493.212 236.505 517.397 241.512 536.147 251.526C555.111 261.328 569.068 275.072 578.018 292.758C587.18 310.443 591.761 330.899 591.761 354.124C591.761 377.35 587.18 397.912 578.018 415.811C569.068 433.709 555.218 447.772 536.467 458C517.716 468.228 493.638 473.342 464.233 473.342H374.924C363.878 473.342 354.924 464.387 354.924 453.342V265.445C354.924 249.462 367.881 236.505 383.864 236.505H463.595Z" fill="#FDFDFC"/>
+</svg>

package/templates/scripts/add-language.mjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+// File: scripts/add-language.mjs
+// Purpose: Add/update a locale in i18n config and propagate localized stubs across labels/about/cases.
+// Author: Lio Schimanko
+
+// MARK: IMPORTS
+import fs from 'node:fs';
+import { readLocaleConfigFromI18nConfig, resolveI18nConfigPath } from './i18n-config-utils.mjs';
+import { runLocaleSync } from './sync-locales.mjs';
+
+// MARK: CONFIG PATTERNS
+const LANGUAGE_CONFIG_REGEX = /export\s+const\s+LANGUAGE_CONFIG\s*=\s*Object\.freeze\(\s*(\{[\s\S]*?\})\s*\);/;
+const RTL_LOCALE_CODES_REGEX = /export\s+const\s+RTL_LOCALE_CODES\s*=\s*Object\.freeze\(\s*(\[[\s\S]*?\])\s*\);/;
+
+// MARK: ARGUMENT AND LITERAL PARSING
+// Parses object-like CLI literals as JSON first, then falls back to JS object syntax.
+function parseConfigLiteral(literalText, fallbackValue = null) {
+  const raw = String(literalText || '').trim();
+  if (!raw) return fallbackValue;
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    try {
+      const evaluateLiteral = new Function(`return (${raw});`);
+      return evaluateLiteral();
+    } catch {
+      return fallbackValue;
+    }
+  }
+}
+
+// Parses supported CLI flags for locale code, display name, html lang, and direction.
+function parseArgs(argv) {
+  const parsed = {
+    code: '',
+    name: '',
+    htmlLang: '',
+    direction: ''
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--code') {
+      parsed.code = String(argv[i + 1] || '').trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--name') {
+      parsed.name = String(argv[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--html-lang' || token === '--htmlLang') {
+      parsed.htmlLang = String(argv[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--direction') {
+      parsed.direction = String(argv[i + 1] || '').trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--rtl') {
+      parsed.direction = 'rtl';
+      continue;
+    }
+
+    if (token === '--ltr') {
+      parsed.direction = 'ltr';
+      continue;
+    }
+  }
+
+  return parsed;
+}
+
+// Derives a default html lang value from a locale code when one is not supplied.
+function toDefaultHtmlLang(localeCode) {
+  const parts = String(localeCode || '').split('-').filter(Boolean);
+  const base = String(parts[0] || '').toLowerCase();
+  if (!base) return 'en-US';
+
+  if (parts.length > 1) {
+    return `${base}-${parts[1].toUpperCase()}`;
+  }
+
+  return `${base}-${base.toUpperCase()}`;
+}
+
+// Validates locale code syntax used by i18n config keys.
+function validateLocaleCode(localeCode) {
+  return /^[a-z]{2,3}(?:-[a-z0-9]+)*$/i.test(String(localeCode || '').trim());
+}
+
+// Validates writing direction values accepted by runtime locale metadata.
+function validateDirection(direction) {
+  return direction === 'rtl' || direction === 'ltr';
+}
+
+// Serializes LANGUAGE_CONFIG back into the expected frozen export format.
+function formatLanguageConfigBlock(nextLanguageConfig) {
+  return `export const LANGUAGE_CONFIG = Object.freeze(${JSON.stringify(nextLanguageConfig, null, 2)});`;
+}
+
+// Serializes RTL locale list into the expected frozen export format.
+function formatRtlLocaleCodesBlock(nextRtlLocaleCodes) {
+  return `export const RTL_LOCALE_CODES = Object.freeze(${JSON.stringify(nextRtlLocaleCodes, null, 2)});`;
+}
+
+// MARK: LANGUAGE MUTATION WORKFLOW
+// Adds or updates one locale entry and then syncs locale-dependent content files.
+export async function runAddLanguage(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const localeCode = String(options.code || '').trim().toLowerCase();
+  const displayName = String(options.name || '').trim();
+  const htmlLang = String(options.htmlLang || '').trim() || toDefaultHtmlLang(localeCode);
+  const requestedDirection = String(options.direction || '').trim().toLowerCase();
+  const direction = requestedDirection || 'ltr';
+
+  if (!validateLocaleCode(localeCode)) {
+    throw new Error('Invalid locale code. Use values like "it", "es", or "pt-BR".');
+  }
+
+  if (!displayName) {
+    throw new Error('Missing language display name. Use --name "Italiano".');
+  }
+
+  if (!validateDirection(direction)) {
+    throw new Error('Invalid direction. Use --direction ltr or --direction rtl (or --rtl/--ltr).');
+  }
+
+  const i18nConfigPath = resolveI18nConfigPath(cwd);
+  if (!fs.existsSync(i18nConfigPath)) {
+    throw new Error(`Could not find i18n config file at ${i18nConfigPath}`);
+  }
+
+  const source = fs.readFileSync(i18nConfigPath, 'utf8');
+  const languageConfigMatch = source.match(LANGUAGE_CONFIG_REGEX);
+  if (!languageConfigMatch?.[1]) {
+    throw new Error(`LANGUAGE_CONFIG block was not found in ${i18nConfigPath}`);
+  }
+
+  let languageConfig = {};
+  let rtlLocaleCodes = [];
+  languageConfig = parseConfigLiteral(languageConfigMatch[1], null);
+  if (!languageConfig || typeof languageConfig !== 'object' || Array.isArray(languageConfig)) {
+    throw new Error(`LANGUAGE_CONFIG is not valid JSON in ${i18nConfigPath}`);
+  }
+
+  const rtlLocaleCodesMatch = source.match(RTL_LOCALE_CODES_REGEX);
+  if (rtlLocaleCodesMatch?.[1]) {
+    const parsed = parseConfigLiteral(rtlLocaleCodesMatch[1], null);
+    if (Array.isArray(parsed)) {
+      rtlLocaleCodes = parsed;
+    } else {
+      throw new Error(`RTL_LOCALE_CODES is not valid JSON in ${i18nConfigPath}`);
+    }
+  }
+
+  rtlLocaleCodes = rtlLocaleCodes
+    .map((value) => String(value || '').trim().toLowerCase())
+    .filter((value, index, list) => value.length > 0 && list.indexOf(value) === index);
+
+  const existed = Boolean(languageConfig[localeCode]);
+  const currentEntry = existed ? languageConfig[localeCode] : null;
+  const currentName = String(currentEntry?.name || '').trim();
+  const currentHtmlLang = String(currentEntry?.htmlLang || '').trim();
+  const currentlyRtl = rtlLocaleCodes.includes(localeCode);
+  const wantsRtl = direction === 'rtl';
+  const unchanged = existed && currentName === displayName && currentHtmlLang === htmlLang && currentlyRtl === wantsRtl;
+
+  if (unchanged) {
+    const localeConfig = readLocaleConfigFromI18nConfig(i18nConfigPath);
+    return {
+      existed,
+      unchanged: true,
+      localeCode,
+      displayName,
+      htmlLang,
+      direction,
+      i18nConfigPath,
+      localeCodes: localeConfig.supportedLocales,
+      syncResult: { updatedFiles: 0, localeCodes: localeConfig.supportedLocales }
+    };
+  }
+
+  languageConfig[localeCode] = {
+    name: displayName,
+    htmlLang
+  };
+
+  if (wantsRtl) {
+    if (!rtlLocaleCodes.includes(localeCode)) {
+      rtlLocaleCodes.push(localeCode);
+    }
+  } else {
+    rtlLocaleCodes = rtlLocaleCodes.filter((code) => code !== localeCode);
+  }
+
+  rtlLocaleCodes = rtlLocaleCodes
+    .map((value) => String(value || '').trim().toLowerCase())
+    .filter((value, index, list) => value.length > 0 && list.indexOf(value) === index)
+    .sort((a, b) => a.localeCompare(b));
+
+  const nextBlock = formatLanguageConfigBlock(languageConfig);
+  let nextSource = source.replace(LANGUAGE_CONFIG_REGEX, nextBlock);
+  if (RTL_LOCALE_CODES_REGEX.test(nextSource)) {
+    nextSource = nextSource.replace(RTL_LOCALE_CODES_REGEX, formatRtlLocaleCodesBlock(rtlLocaleCodes));
+  }
+
+  if (nextSource !== source) {
+    fs.writeFileSync(i18nConfigPath, nextSource, 'utf8');
+  }
+
+  const syncResult = await runLocaleSync({ cwd });
+  const localeConfig = readLocaleConfigFromI18nConfig(i18nConfigPath);
+
+  return {
+    existed,
+    unchanged: false,
+    localeCode,
+    displayName,
+    htmlLang,
+    direction,
+    i18nConfigPath,
+    localeCodes: localeConfig.supportedLocales,
+    syncResult
+  };
+}
+
+// MARK: SCRIPT ENTRYPOINT
+// CLI entrypoint for add-language script usage.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = parseArgs(process.argv.slice(2));
+
+  runAddLanguage(args)
+    .then((result) => {
+      const operation = result.existed ? 'Updated' : 'Added';
+      console.log(`[add-language] ${operation} ${result.localeCode} (${result.displayName}) with htmlLang=${result.htmlLang} and direction=${result.direction}.`);
+      console.log(`[add-language] Locales: ${result.localeCodes.join(', ')}`);
+      console.log(`[add-language] Synced ${result.syncResult.updatedFiles} file(s).`);
+    })
+    .catch((error) => {
+      console.error('[add-language] Failed:', error.message || error);
+      process.exit(1);
+    });
+}

package/templates/scripts/convert-video-to-mp4.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// File: templates/scripts/convert-video-to-mp4.mjs
+// Purpose: Convert video files to MP4 and write outputs beside original files.
+// Author: Lio Schimanko
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const SKIPPED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist']);
+const VIDEO_EXTENSIONS = new Set([
+  '.avi',
+  '.flv',
+  '.m2ts',
+  '.m4v',
+  '.mkv',
+  '.mov',
+  '.mpeg',
+  '.mpg',
+  '.mts',
+  '.webm',
+  '.wmv',
+  '.3gp'
+]);
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const options = {
+    dir: process.cwd(),
+    force: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+
+    if ((token === '--dir' || token === '--input') && args[i + 1]) {
+      options.dir = path.resolve(String(args[i + 1]));
+      i += 1;
+      continue;
+    }
+
+    if (token === '--force') {
+      options.force = true;
+      continue;
+    }
+
+    if (token === '--help' || token === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log('Usage: npm run convert:video -- [--dir <path>] [--force]');
+  console.log('');
+  console.log('Options:');
+  console.log('  --dir, --input  Root directory to scan recursively for video files');
+  console.log('  --force         Overwrite existing .mp4 targets');
+  console.log('  --help, -h      Show help');
+}
+
+function verifyFfmpeg() {
+  const result = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
+  if (result.error || result.status !== 0) {
+    throw new Error('ffmpeg is required. Install it first (for macOS: brew install ffmpeg).');
+  }
+}
+
+function collectVideoFiles(rootDir, output = []) {
+  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const absolutePath = path.join(rootDir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (SKIPPED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      collectVideoFiles(absolutePath, output);
+      continue;
+    }
+
+    const extension = path.extname(entry.name).toLowerCase();
+    if (entry.isFile() && VIDEO_EXTENSIONS.has(extension)) {
+      output.push(absolutePath);
+    }
+  }
+
+  return output;
+}
+
+function convertOneFile(inputPath, force = false) {
+  const directory = path.dirname(inputPath);
+  const baseName = path.basename(inputPath, path.extname(inputPath));
+  const outputPath = path.join(directory, `${baseName}.mp4`);
+
+  if (fs.existsSync(outputPath) && !force) {
+    return {
+      status: 'skipped',
+      inputPath,
+      outputPath,
+      reason: 'target exists'
+    };
+  }
+
+  const ffmpegArgs = [
+    '-hide_banner',
+    '-loglevel',
+    'error',
+    force ? '-y' : '-n',
+    '-i',
+    inputPath,
+    '-c:v',
+    'libx264',
+    '-preset',
+    'medium',
+    '-crf',
+    '23',
+    '-c:a',
+    'aac',
+    '-b:a',
+    '192k',
+    '-movflags',
+    '+faststart',
+    outputPath
+  ];
+
+  const result = spawnSync('ffmpeg', ffmpegArgs, {
+    encoding: 'utf8'
+  });
+
+  if (result.error || result.status !== 0) {
+    return {
+      status: 'failed',
+      inputPath,
+      outputPath,
+      reason: (result.stderr || result.error?.message || 'conversion failed').trim()
+    };
+  }
+
+  return {
+    status: 'converted',
+    inputPath,
+    outputPath
+  };
+}
+
+function main() {
+  const options = parseArgs(process.argv);
+
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (!fs.existsSync(options.dir) || !fs.statSync(options.dir).isDirectory()) {
+    console.error(`[convert:video] Invalid directory: ${options.dir}`);
+    process.exit(1);
+  }
+
+  verifyFfmpeg();
+
+  const videoFiles = collectVideoFiles(options.dir);
+  if (videoFiles.length === 0) {
+    console.log(`[convert:video] No video files found under ${options.dir}`);
+    process.exit(0);
+  }
+
+  let converted = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const inputPath of videoFiles) {
+    const result = convertOneFile(inputPath, options.force);
+
+    if (result.status === 'converted') {
+      converted += 1;
+      console.log(`[convert:video] Converted: ${result.outputPath}`);
+      continue;
+    }
+
+    if (result.status === 'skipped') {
+      skipped += 1;
+      console.log(`[convert:video] Skipped: ${result.outputPath} (${result.reason})`);
+      continue;
+    }
+
+    failed += 1;
+    console.error(`[convert:video] Failed: ${result.inputPath}`);
+    console.error(`[convert:video] Reason: ${result.reason}`);
+  }
+
+  console.log(`[convert:video] Done. converted=${converted} skipped=${skipped} failed=${failed}`);
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[convert:video] ${error?.message || String(error)}`);
+  process.exit(1);
+}