|
|
|
|
|
|
|
|
|
|
|
|
|
|
| import { MarkdownParser } from '../../shared/markdown-parser.js';
|
| import { buildLayoutTreeForSlide, LayoutNodeKind } from '../../shared/layout-schema.js';
|
| import { VideoRenderer, blobToBase64 } from './video-renderer.js';
|
| import { applyTemplate, getAllTemplates } from './templates.js';
|
| import {
|
| getAllPresets,
|
| loadPreset,
|
| getCurrentConfig,
|
| updateConfigPart,
|
| initPresentationUI,
|
| reloadUI,
|
| loadConfigFromFrontmatter,
|
| resetConfig,
|
| computeSafeZoneMargins,
|
| SAFE_ZONE_CONFIG,
|
| getSmartLayoutFillRatio,
|
| getSmartLayoutStageFallback,
|
| SMART_LAYOUT_CONFIG,
|
| loadSavedConfig,
|
| exportConfigToFile,
|
| importConfigFromFile,
|
| setDisplayMode,
|
| getDisplayMode,
|
| getSafeZoneConfig
|
| } from './presentation-config.js';
|
| import { SlideEditor } from './slide-editor.js';
|
| import { ConfigStorage } from './config-storage.js';
|
| import {
|
| switchToIntroMode,
|
| switchToPresentationMode,
|
| switchToEditorMode,
|
| getModeManager
|
| } from './mode-manager.js';
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| const SMART_LAYOUT_FILL_RATIO = 0.92;
|
| const SMART_LAYOUT_STAGE_FALLBACK = { width: 1280, height: 720 };
|
|
|
|
|
|
|
| const SMART_SAFE_ZONE = {
|
| horizontalRatio: 0.06,
|
| verticalRatio: 0.08,
|
| maxHorizontalRatio: 0.12,
|
| maxVerticalRatio: 0.15,
|
| minHorizontal: 40,
|
| minVertical: 40
|
| };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function clamp(value, min, max) {
|
| return Math.min(Math.max(value, min), max);
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| function computeSafeZoneInsets(stageRect = {}) {
|
|
|
| return computeSafeZoneMargins(stageRect);
|
| }
|
|
|
| |
| |
| |
|
|
| function formatSafeZonePadding(insets) {
|
| return `${Math.round(insets.top)}px ${Math.round(insets.right)}px ${Math.round(insets.bottom)}px ${Math.round(insets.left)}px`;
|
| }
|
|
|
| |
| |
| |
|
|
| function applySafeZonePadding(target, insets) {
|
| if (!target || !insets) return;
|
|
|
| const paddingValue = formatSafeZonePadding(insets);
|
| target.style.boxSizing = 'border-box';
|
| target.style.padding = paddingValue;
|
| target.style.setProperty('--smart-safe-padding', paddingValue);
|
|
|
| target.dataset.safeTop = String(Math.round(insets.top));
|
| target.dataset.safeBottom = String(Math.round(insets.bottom));
|
| target.dataset.safeLeft = String(Math.round(insets.left));
|
| target.dataset.safeRight = String(Math.round(insets.right));
|
| }
|
|
|
| const state = {
|
| markdown: '',
|
| frontmatter: {},
|
| slides: [],
|
| totalDuration: 0,
|
| template: 'modern',
|
| videoConfig: {
|
| resolution: '1920x1080',
|
| fps: 60,
|
| quality: 0.95
|
| },
|
| themeConfig: {
|
| accent: '#60a5fa'
|
| },
|
| isPlaying: false,
|
| isPaused: false,
|
| isPresentationMode: false,
|
| currentSlideIndex: 0,
|
| pauseResolve: null,
|
| errors: [],
|
| warnings: [],
|
| screenSensor: {
|
| width: window.innerWidth,
|
| height: window.innerHeight,
|
| pixelRatio: window.devicePixelRatio || 1,
|
| isLargeScreen: false,
|
| screenType: 'normal',
|
| isFullscreen: false,
|
| availableSpace: window.innerWidth * window.innerHeight,
|
| lastUpdate: Date.now()
|
| }
|
| };
|
|
|
| const dom = {
|
| stage: document.getElementById('stage'),
|
| stageFrame: document.getElementById('stageFrame'),
|
| pauseOverlay: document.getElementById('pauseOverlay'),
|
| navControls: document.getElementById('navControls'),
|
| prevSlideBtn: document.getElementById('prevSlideBtn'),
|
| nextSlideBtn: document.getElementById('nextSlideBtn'),
|
| slideCounter: document.getElementById('slideCounter'),
|
| fullscreenBtn: document.getElementById('fullscreenBtn'),
|
| sceneElements: null,
|
| statusPill: document.getElementById('statusPill'),
|
| statusLog: document.getElementById('statusLog'),
|
| progressContainer: document.getElementById('progressContainer'),
|
| progressBar: document.getElementById('progressBar'),
|
| progressText: document.getElementById('progressText'),
|
| markdownEditor: document.getElementById('markdownEditor'),
|
| markdownDiagnostics: document.getElementById('markdownDiagnostics'),
|
| markdownSummary: document.getElementById('markdownSummary'),
|
| timelineTotal: document.getElementById('timelineTotal'),
|
| timelineSceneList: document.getElementById('timelineSceneList'),
|
| assetChecklist: document.getElementById('assetChecklist'),
|
| templatesContainer: document.getElementById('templatesContainer'),
|
| templateActiveLabel: document.getElementById('templateActiveLabel'),
|
|
|
| presetSelector: document.getElementById('presetSelector'),
|
| fontHeading: document.getElementById('fontHeading'),
|
| fontBody: document.getElementById('fontBody'),
|
| fontCode: document.getElementById('fontCode'),
|
| colorPrimary: document.getElementById('colorPrimary'),
|
| colorAccent: document.getElementById('colorAccent'),
|
| colorBackground: document.getElementById('colorBackground'),
|
| colorText: document.getElementById('colorText'),
|
| animationTransition: document.getElementById('animationTransition'),
|
| animationDuration: document.getElementById('animationDuration'),
|
|
|
| fontSizeH1Min: document.getElementById('fontSizeH1Min'),
|
| fontSizeH1Base: document.getElementById('fontSizeH1Base'),
|
| fontSizeH1Max: document.getElementById('fontSizeH1Max'),
|
| fontSizeH2Min: document.getElementById('fontSizeH2Min'),
|
| fontSizeH2Base: document.getElementById('fontSizeH2Base'),
|
| fontSizeH2Max: document.getElementById('fontSizeH2Max'),
|
| fontSizeTextMin: document.getElementById('fontSizeTextMin'),
|
| fontSizeTextBase: document.getElementById('fontSizeTextBase'),
|
| fontSizeTextMax: document.getElementById('fontSizeTextMax'),
|
| lineHeightHeading: document.getElementById('lineHeightHeading'),
|
| lineHeightBody: document.getElementById('lineHeightBody'),
|
|
|
| previewOpacity: document.getElementById('previewOpacity'),
|
| overlayBlur: document.getElementById('overlayBlur'),
|
| navBorderWidth: document.getElementById('navBorderWidth'),
|
| backdropSpread: document.getElementById('backdropSpread'),
|
| backdropBlur: document.getElementById('backdropBlur'),
|
|
|
| headingBorderWidth: document.getElementById('headingBorderWidth'),
|
| blockquoteBorderWidth: document.getElementById('blockquoteBorderWidth'),
|
| imageBorderWidth: document.getElementById('imageBorderWidth'),
|
| linkUnderlineWidth: document.getElementById('linkUnderlineWidth'),
|
| tableBorderWidth: document.getElementById('tableBorderWidth'),
|
| hrBorderWidth: document.getElementById('hrBorderWidth'),
|
|
|
| paragraphBefore: document.getElementById('paragraphBefore'),
|
| paragraphAfter: document.getElementById('paragraphAfter'),
|
| headingBefore: document.getElementById('headingBefore'),
|
| headingAfter: document.getElementById('headingAfter'),
|
| indentFirst: document.getElementById('indentFirst'),
|
| indentBlockquote: document.getElementById('indentBlockquote'),
|
| listIndent: document.getElementById('listIndent'),
|
| textAlign: document.getElementById('textAlign'),
|
|
|
| pageIndicatorTop: document.getElementById('pageIndicatorTop'),
|
| pageIndicatorRight: document.getElementById('pageIndicatorRight'),
|
| pageIndicatorFontSize: document.getElementById('pageIndicatorFontSize'),
|
| pageIndicatorOpacity: document.getElementById('pageIndicatorOpacity'),
|
| pageIndicatorPaddingX: document.getElementById('pageIndicatorPaddingX'),
|
| pageIndicatorPaddingY: document.getElementById('pageIndicatorPaddingY'),
|
| pageIndicatorBgColor: document.getElementById('pageIndicatorBgColor'),
|
| pageIndicatorTextColor: document.getElementById('pageIndicatorTextColor'),
|
|
|
| smartListTwoColumn: document.getElementById('smartListTwoColumn'),
|
| smartListThreeColumn: document.getElementById('smartListThreeColumn'),
|
|
|
| contentPaddingSmall: document.getElementById('contentPaddingSmall'),
|
| contentPaddingLarge: document.getElementById('contentPaddingLarge'),
|
| contentPaddingUltra: document.getElementById('contentPaddingUltra'),
|
| contentAlignHorizontal: document.getElementById('contentAlignHorizontal'),
|
| contentAlignVertical: document.getElementById('contentAlignVertical'),
|
|
|
| saveSettingsBtn: document.getElementById('saveSettingsBtn'),
|
| resetSettingsBtn: document.getElementById('resetSettingsBtn'),
|
|
|
| syncMarkdownBtn: document.getElementById('syncMarkdownBtn'),
|
| loadMarkdownSample: document.getElementById('loadMarkdownSample'),
|
| importMarkdownBtn: document.getElementById('importMarkdownBtn'),
|
| openWorkspaceBtn: document.getElementById('openWorkspaceBtn'),
|
| presentationModeBtn: document.getElementById('presentationModeBtn'),
|
| exitPresentationBtn: document.getElementById('exitPresentationBtn'),
|
| stopPreviewBtn: document.getElementById('stopPreviewBtn'),
|
| stopExportBtn: document.getElementById('stopExportBtn'),
|
| previewBtn: document.getElementById('previewBtn'),
|
| recordWebMBtn: document.getElementById('recordWebMBtn'),
|
| resetBtn: document.getElementById('resetBtn'),
|
| securityBtn: document.getElementById('securityBtn'),
|
| measurementStage: null,
|
| measurementScene: null,
|
| measurementRoot: null
|
| };
|
|
|
| function flattenLayoutTree(layout) {
|
| if (!layout || !Array.isArray(layout.sections)) {
|
| return [];
|
| }
|
|
|
| const items = [];
|
|
|
| layout.sections.forEach(section => {
|
| const sectionId = section.id;
|
| section.blocks.forEach(block => {
|
| const baseMeta = {
|
| layoutBlockId: block.id,
|
| layoutBlockKind: block.kind,
|
| sectionId
|
| };
|
|
|
| switch (block.kind) {
|
| case LayoutNodeKind.HEADING: {
|
| const level = Math.min(Math.max(block.level || 1, 1), 6);
|
| items.push({
|
| ...baseMeta,
|
| type: `h${level}`,
|
| content: block.text || '',
|
| html: block.html || null
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.TEXT: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'text',
|
| content: block.text || '',
|
| html: block.html || null
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.LIST: {
|
| const listType = block.listType;
|
| block.items.forEach((listItem, index) => {
|
| let type = 'list-item';
|
| if (listType === 'ordered') type = 'numbered-item';
|
| if (listType === 'task') type = 'task-list';
|
|
|
| items.push({
|
| ...baseMeta,
|
| type,
|
| content: listItem.text || '',
|
| marker: listItem.marker || '•',
|
| number: listItem.number || index + 1,
|
| checked: !!listItem.checked,
|
| listId: block.id,
|
| listItemId: listItem.id,
|
| html: listItem.html || null
|
| });
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.CODE: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'code',
|
| content: block.content || '',
|
| language: block.language || 'text'
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.TABLE: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'table',
|
| rows: block.rows || []
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.CALLOUT: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'blockquote',
|
| content: block.text || '',
|
| html: block.html || null
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.IMAGE: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'image',
|
| src: block.src,
|
| alt: block.alt || '',
|
| title: block.title || ''
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.DIVIDER: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'hr'
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.HTML: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'html',
|
| content: block.html || '',
|
| html: block.html || null
|
| });
|
| break;
|
| }
|
| case LayoutNodeKind.LINK: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'link',
|
| text: block.text || block.href || '',
|
| url: block.href || '',
|
| title: block.title || '',
|
| html: block.html || null
|
| });
|
| break;
|
| }
|
| default: {
|
| items.push({
|
| ...baseMeta,
|
| type: 'text',
|
| content: block.text || block.content || '',
|
| html: block.html || null
|
| });
|
| }
|
| }
|
| });
|
| });
|
|
|
| return items;
|
| }
|
|
|
| function enrichSlidesWithLayout(slides) {
|
| return slides.map(slide => {
|
| const layout = buildLayoutTreeForSlide(slide);
|
| const renderItems = flattenLayoutTree(layout);
|
| const visualLines = slide.visualLines != null ? slide.visualLines : layout?.metrics?.estimatedLines;
|
|
|
| return {
|
| ...slide,
|
| layout,
|
| renderItems,
|
| visualLines
|
| };
|
| });
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function ensureMeasurementStage() {
|
| if (!dom.measurementStage) {
|
| const measurementStage = document.createElement('div');
|
| measurementStage.id = 'smartMeasurementStage';
|
| measurementStage.style.position = 'fixed';
|
| measurementStage.style.top = '-10000px';
|
| measurementStage.style.left = '-10000px';
|
| measurementStage.style.visibility = 'hidden';
|
| measurementStage.style.pointerEvents = 'none';
|
| measurementStage.style.zIndex = '-1';
|
|
|
| const measurementScene = document.createElement('div');
|
| measurementScene.className = 'scene active';
|
| measurementScene.dataset.scene = 'body';
|
|
|
| const measurementRoot = document.createElement('div');
|
| measurementRoot.className = 'smart-layout-root relative z-10 space-y-4';
|
|
|
| measurementScene.appendChild(measurementRoot);
|
| measurementStage.appendChild(measurementScene);
|
|
|
| document.body.appendChild(measurementStage);
|
| dom.measurementStage = measurementStage;
|
| dom.measurementScene = measurementScene;
|
| dom.measurementRoot = measurementRoot;
|
| }
|
|
|
| updateMeasurementStageSize();
|
|
|
| if (dom.measurementRoot) {
|
| dom.measurementRoot.innerHTML = '';
|
| }
|
|
|
| return dom.measurementRoot;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function updateMeasurementStageSize() {
|
| if (!dom.measurementStage) return;
|
|
|
| dom.measurementRoot.innerHTML = '';
|
|
|
| const stageRect = dom.stage
|
| ? dom.stage.getBoundingClientRect()
|
| : dom.stageFrame
|
| ? dom.stageFrame.getBoundingClientRect()
|
| : getSmartLayoutStageFallback();
|
|
|
| dom.measurementStage.style.width = `${stageRect.width}px`;
|
| dom.measurementStage.style.height = `${stageRect.height}px`;
|
|
|
| const screenType = state.screenSensor?.screenType || 'normal';
|
| dom.measurementStage.classList.remove('screen-normal', 'screen-large', 'screen-ultra');
|
| dom.measurementStage.classList.add(`screen-${screenType}`);
|
|
|
| if (dom.measurementScene) {
|
|
|
| const root = document.documentElement;
|
| const paddingSmall = parseInt(root.style.getPropertyValue('--content-padding-small')) || 40;
|
| const paddingLarge = parseInt(root.style.getPropertyValue('--content-padding-large')) || 48;
|
| const paddingUltra = parseInt(root.style.getPropertyValue('--content-padding-ultra')) || 64;
|
| const alignHorizontal = root.style.getPropertyValue('--content-align-horizontal') || 'center';
|
| const alignVertical = root.style.getPropertyValue('--content-align-vertical') || 'center';
|
|
|
| let paddingTop = paddingSmall;
|
| let paddingSides = paddingSmall;
|
|
|
| if (screenType === 'large') {
|
| paddingTop = paddingLarge;
|
| paddingSides = paddingLarge;
|
| } else if (screenType === 'ultra') {
|
| paddingTop = paddingUltra;
|
| paddingSides = paddingUltra;
|
| }
|
|
|
|
|
| dom.measurementScene.style.justifyContent = alignHorizontal;
|
| dom.measurementScene.style.alignItems = alignVertical;
|
|
|
| dom.measurementScene.style.paddingTop = `${paddingTop}px`;
|
| dom.measurementScene.style.paddingBottom = `${paddingTop}px`;
|
| dom.measurementScene.style.paddingLeft = `${paddingSides}px`;
|
| dom.measurementScene.style.paddingRight = `${paddingSides}px`;
|
| }
|
|
|
| if (dom.measurementRoot) {
|
| dom.measurementRoot.style.width = '100%';
|
| dom.measurementRoot.style.maxWidth = '100%';
|
| }
|
| }
|
|
|
| function setupTabs() {
|
| const tabButtons = document.querySelectorAll('.tab-button');
|
| const tabContents = document.querySelectorAll('.tab-content');
|
|
|
| tabButtons.forEach(button => {
|
| button.addEventListener('click', () => {
|
| const tabName = button.dataset.tab;
|
|
|
| tabButtons.forEach(btn => btn.classList.remove('active'));
|
| tabContents.forEach(content => content.classList.remove('active'));
|
|
|
| button.classList.add('active');
|
| const target = document.querySelector(`[data-tab-content="${tabName}"]`);
|
| if (target) {
|
| target.classList.add('active');
|
| }
|
| });
|
| });
|
| }
|
|
|
| function getTemplateEmoji(templateId) {
|
| const icons = {
|
| modern: '◆',
|
| classic: '■',
|
| minimal: '○',
|
| mono: '●',
|
| rounded: '◉',
|
| space: '▲',
|
| code: '◈',
|
| tech: '◐',
|
| display: '▼',
|
| corporate: '□'
|
| };
|
| return icons[templateId] || '◇';
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupPresentationSettings() {
|
|
|
| initPresentationUI(dom, {
|
| onUpdate: updateStagePreview,
|
| onSave: savePresentationSettings,
|
| setStatus: setStatus
|
| });
|
| }
|
|
|
| function savePresentationSettings(config, presetName) {
|
|
|
|
|
|
|
|
|
| console.log('[App] ℹ️ Config auto-saved to localStorage');
|
| console.log('[App] Current preset:', presetName || 'custom');
|
|
|
|
|
|
|
| }
|
|
|
| function setupTemplates() {
|
| if (!dom.templatesContainer) return;
|
|
|
| dom.templatesContainer.innerHTML = '';
|
| const templates = getAllTemplates();
|
|
|
| templates.forEach(template => {
|
| const card = document.createElement('div');
|
| card.className = `template-card ${template.id === state.template ? 'active' : ''}`;
|
| card.innerHTML = `
|
| <div class="text-2xl mb-2">${getTemplateEmoji(template.id)}</div>
|
| <div class="font-semibold text-sm mb-1">${template.name}</div>
|
| <div class="text-xs text-slate-400">${template.description}</div>
|
| `;
|
|
|
| card.addEventListener('click', () => selectTemplate(template.id));
|
| dom.templatesContainer.appendChild(card);
|
| });
|
| }
|
|
|
| function selectTemplate(templateId) {
|
| state.template = templateId;
|
|
|
| const cards = dom.templatesContainer ? dom.templatesContainer.querySelectorAll('.template-card') : [];
|
| cards.forEach(card => card.classList.remove('active'));
|
| const templates = getAllTemplates();
|
| const index = templates.findIndex(t => t.id === templateId);
|
| if (cards[index]) {
|
| cards[index].classList.add('active');
|
| }
|
|
|
| applyTemplate(templateId);
|
| updateTemplateUI();
|
| upsertFrontmatterValue('template', templateId);
|
|
|
| if (state.slides.length > 0) {
|
| syncMarkdown();
|
| }
|
|
|
| setStatus(`Template: ${templateId}`, 'online');
|
| }
|
|
|
| function updateTemplateUI() {
|
| if (!dom.templateActiveLabel) return;
|
| dom.templateActiveLabel.textContent = state.template;
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupMarkdownControls() {
|
| dom.syncMarkdownBtn.addEventListener('click', syncMarkdown);
|
| dom.loadMarkdownSample.addEventListener('click', loadSampleDeck);
|
| dom.importMarkdownBtn.addEventListener('click', importMarkdownFile);
|
| dom.openWorkspaceBtn.addEventListener('click', openWorkspaceFolder);
|
|
|
| let markdownTimeout;
|
| dom.markdownEditor.addEventListener('input', () => {
|
| clearTimeout(markdownTimeout);
|
| markdownTimeout = setTimeout(() => {
|
| dom.syncMarkdownBtn.classList.add('pulse');
|
| }, 1000);
|
| });
|
|
|
|
|
| setupMarkdownDropZone();
|
| }
|
|
|
| |
| |
|
|
| function setupMarkdownDropZone() {
|
| const dropZone = document.getElementById('markdownDropZone');
|
| const textarea = dom.markdownEditor;
|
| const overlay = dropZone?.querySelector('.drop-overlay');
|
|
|
| if (!dropZone || !textarea || !overlay) return;
|
|
|
|
|
| ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
|
| dropZone.addEventListener(eventName, preventDefaults, false);
|
| document.body.addEventListener(eventName, preventDefaults, false);
|
| });
|
|
|
| function preventDefaults(e) {
|
| e.preventDefault();
|
| e.stopPropagation();
|
| }
|
|
|
|
|
| ['dragenter', 'dragover'].forEach(eventName => {
|
| dropZone.addEventListener(eventName, () => {
|
| dropZone.classList.add('drag-over');
|
| overlay.classList.remove('hidden');
|
| }, false);
|
| });
|
|
|
| ['dragleave', 'drop'].forEach(eventName => {
|
| dropZone.addEventListener(eventName, () => {
|
| dropZone.classList.remove('drag-over');
|
| overlay.classList.add('hidden');
|
| }, false);
|
| });
|
|
|
|
|
| dropZone.addEventListener('drop', handleDrop, false);
|
|
|
| async function handleDrop(e) {
|
| const dt = e.dataTransfer;
|
| const files = dt.files;
|
|
|
| if (files.length === 0) return;
|
|
|
| const file = files[0];
|
| const fileName = file.name.toLowerCase();
|
|
|
|
|
| if (!fileName.endsWith('.md') &&
|
| !fileName.endsWith('.markdown') &&
|
| !fileName.endsWith('.txt')) {
|
| setStatus('Please drop a markdown file (.md, .markdown, .txt)', 'online');
|
| return;
|
| }
|
|
|
| try {
|
| const text = await file.text();
|
| textarea.value = text;
|
| setStatus(`Loaded: ${file.name} (${formatFileSize(file.size)})`, 'online');
|
| dom.syncMarkdownBtn.classList.add('pulse');
|
|
|
|
|
| if (text.trim().length > 0) {
|
| setTimeout(() => {
|
| syncMarkdown();
|
| }, 500);
|
| }
|
| } catch (error) {
|
| console.error('[App] Drop error:', error);
|
| setStatus('Failed to read file', 'online');
|
| }
|
| }
|
| }
|
|
|
| |
| |
|
|
| function formatFileSize(bytes) {
|
| if (bytes < 1024) return bytes + ' B';
|
| if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
|
| return (bytes / 1024 / 1024).toFixed(1) + ' MB';
|
| }
|
|
|
| async function syncMarkdown() {
|
| try {
|
| dom.syncMarkdownBtn.classList.remove('pulse');
|
| dom.syncMarkdownBtn.textContent = 'Sync Markdown';
|
| setStatus('Parsing markdown...', 'online');
|
|
|
| state.markdown = dom.markdownEditor.value;
|
|
|
| parseFrontmatter();
|
|
|
|
|
| const slideBreakMode = state.frontmatter.slideBreak || 'auto';
|
| let parserOptions = {
|
| h1AsSlide: true,
|
| h2AsSlide: true,
|
| slideBreak: '---'
|
| };
|
|
|
| switch (slideBreakMode) {
|
| case 'h1':
|
| parserOptions.h1AsSlide = true;
|
| parserOptions.h2AsSlide = false;
|
| break;
|
| case 'h2':
|
| parserOptions.h1AsSlide = false;
|
| parserOptions.h2AsSlide = true;
|
| break;
|
| case 'delimiter':
|
| case 'manual':
|
| parserOptions.h1AsSlide = false;
|
| parserOptions.h2AsSlide = false;
|
| break;
|
| case 'auto':
|
| default:
|
| parserOptions.h1AsSlide = true;
|
| parserOptions.h2AsSlide = true;
|
| }
|
|
|
| const parser = new MarkdownParser(parserOptions);
|
| const parsedSlides = parser.parse(state.markdown);
|
| state.slides = enrichSlidesWithLayout(parsedSlides);
|
| state.totalDuration = state.slides.reduce((sum, slide) => sum + slide.duration, 0);
|
|
|
| validateMarkdown();
|
| updateMarkdownSummary();
|
| updateTimelineUI();
|
| updateStagePreview();
|
| applyConfigFromFrontmatter();
|
|
|
| if (state.errors.length === 0) {
|
| dom.markdownDiagnostics.classList.add('hidden');
|
| setStatus(`Synced: ${state.slides.length} slides, ${formatDuration(state.totalDuration)}`, 'online');
|
| } else {
|
| showDiagnostics();
|
| }
|
|
|
| } catch (error) {
|
| console.error('[App] Sync error:', error);
|
| state.errors.push(`Parse error: ${error.message}`);
|
| showDiagnostics();
|
| setStatus('Sync failed - see diagnostics', 'online');
|
| }
|
| }
|
|
|
| function parseFrontmatter() {
|
| state.frontmatter = {};
|
| const lines = state.markdown.split('\n');
|
| let inFrontmatter = false;
|
| let frontmatterLines = [];
|
| let foundClosing = false;
|
|
|
|
|
| const startLine = lines[0].trim() === '' ? 1 : 0;
|
|
|
| for (let i = startLine; i < lines.length; i++) {
|
| const line = lines[i].trim();
|
|
|
|
|
| if (line === '---' && !inFrontmatter && i === startLine) {
|
| inFrontmatter = true;
|
| continue;
|
| }
|
|
|
|
|
| if (line === '---' && inFrontmatter) {
|
| foundClosing = true;
|
| break;
|
| }
|
|
|
|
|
| if (inFrontmatter) {
|
|
|
| if (i - startLine > 50) {
|
| console.warn('[App] Frontmatter not closed within 50 lines, ignoring');
|
| state.frontmatter = {};
|
| return;
|
| }
|
| frontmatterLines.push(line);
|
| }
|
| }
|
|
|
|
|
| if (!foundClosing) {
|
| state.frontmatter = {};
|
| return;
|
| }
|
|
|
|
|
| frontmatterLines.forEach(line => {
|
| const match = line.match(/^([^:]+):\s*(.+)$/);
|
| if (match) {
|
| const key = match[1].trim();
|
| let value = match[2].trim().replace(/^["']|["']$/g, '');
|
| state.frontmatter[key] = value;
|
| }
|
| });
|
| }
|
|
|
| function upsertFrontmatterValue(key, value) {
|
| state.frontmatter[key] = value;
|
| const lines = dom.markdownEditor.value.split('\n');
|
| let inFrontmatter = false;
|
| let frontmatterStartIndex = -1;
|
| let frontmatterEndIndex = -1;
|
| let keyFound = false;
|
|
|
|
|
| for (let i = 0; i < lines.length; i++) {
|
| const line = lines[i].trim();
|
| if (line === '---') {
|
| if (!inFrontmatter) {
|
| inFrontmatter = true;
|
| frontmatterStartIndex = i;
|
| continue;
|
| } else {
|
| frontmatterEndIndex = i;
|
| break;
|
| }
|
| }
|
| }
|
|
|
|
|
| if (frontmatterStartIndex === -1) {
|
| lines.unshift('---', `${key}: ${value}`, '---', '');
|
| dom.markdownEditor.value = lines.join('\n');
|
| return;
|
| }
|
|
|
|
|
| for (let i = frontmatterStartIndex + 1; i < frontmatterEndIndex; i++) {
|
| const line = lines[i].trim();
|
| if (line.startsWith(`${key}:`)) {
|
| lines[i] = `${key}: ${value}`;
|
| keyFound = true;
|
| break;
|
| }
|
| }
|
|
|
|
|
| if (!keyFound && frontmatterEndIndex > 0) {
|
| lines.splice(frontmatterEndIndex, 0, `${key}: ${value}`);
|
| }
|
|
|
| dom.markdownEditor.value = lines.join('\n');
|
| }
|
|
|
| function applyConfigFromFrontmatter() {
|
|
|
|
|
|
|
| const hasSavedConfig = ConfigStorage.hasSavedConfig();
|
|
|
| if (!hasSavedConfig) {
|
|
|
| console.log('[App] No saved config found, loading from markdown frontmatter');
|
| loadConfigFromFrontmatter(state.frontmatter, dom);
|
| } else {
|
| console.log('[App] Using saved config, ignoring markdown frontmatter');
|
| }
|
|
|
|
|
| if (state.frontmatter.template) {
|
| state.template = state.frontmatter.template;
|
| applyTemplate(state.template);
|
| updateTemplateUI();
|
| }
|
|
|
|
|
| if (state.frontmatter['video.resolution']) {
|
| state.videoConfig.resolution = state.frontmatter['video.resolution'];
|
| const resSelect = document.querySelector('[data-config="video.resolution"]');
|
| if (resSelect) resSelect.value = state.videoConfig.resolution;
|
| }
|
|
|
| if (state.frontmatter['video.fps']) {
|
| state.videoConfig.fps = parseInt(state.frontmatter['video.fps']);
|
| const fpsSelect = document.querySelector('[data-config="video.fps"]');
|
| if (fpsSelect) fpsSelect.value = state.videoConfig.fps;
|
| }
|
|
|
| if (state.frontmatter['video.quality']) {
|
| state.videoConfig.quality = parseFloat(state.frontmatter['video.quality']);
|
| const qualitySlider = document.querySelector('[data-config="video.quality"]');
|
| if (qualitySlider) {
|
| qualitySlider.value = state.videoConfig.quality;
|
| document.getElementById('qualityValue').textContent = Math.round(state.videoConfig.quality * 100) + '%';
|
| }
|
| }
|
|
|
|
|
| if (state.frontmatter['theme.accent']) {
|
| state.themeConfig.accent = state.frontmatter['theme.accent'];
|
| const accentInput = document.querySelector('[data-config="theme.accent"]');
|
| if (accentInput) accentInput.value = state.themeConfig.accent;
|
| document.documentElement.style.setProperty('--accent-color', state.themeConfig.accent);
|
| }
|
| }
|
|
|
| function validateMarkdown() {
|
| state.errors = [];
|
| state.warnings = [];
|
|
|
| if (!state.markdown.trim()) {
|
| state.errors.push('Markdown is empty');
|
| return;
|
| }
|
|
|
|
|
| const lines = state.markdown.split('\n');
|
| if (lines[0].trim() === '---') {
|
| let foundClosing = false;
|
| for (let i = 1; i < Math.min(lines.length, 50); i++) {
|
| if (lines[i].trim() === '---') {
|
| foundClosing = true;
|
| break;
|
| }
|
| }
|
| if (!foundClosing) {
|
| state.errors.push('Missing closing frontmatter delimiter (---). Add --- after your frontmatter block.');
|
| }
|
| }
|
|
|
| if (state.slides.length === 0) {
|
| const slideBreak = state.frontmatter.slideBreak || 'auto';
|
| if (slideBreak === 'h1') {
|
| state.errors.push('No slides found - add # headings to create slides (slideBreak: h1 mode)');
|
| } else if (slideBreak === 'h2') {
|
| state.errors.push('No slides found - add ## headings to create slides (slideBreak: h2 mode)');
|
| } else {
|
| state.errors.push('No slides found - add --- separators or # headings');
|
| }
|
| return;
|
| }
|
|
|
|
|
| state.slides.forEach((slide, i) => {
|
| const slideName = (slide.title || '').trim() || `Slide ${i + 1}`;
|
|
|
| if (slide.duration < 2) {
|
| state.warnings.push(`${slideName} is very short (${slide.duration}s) - consider adding more content`);
|
| }
|
| if (slide.duration > 60) {
|
| state.warnings.push(`${slideName} is very long (${slide.duration}s) - consider splitting`);
|
| }
|
| if (slide.content.length === 0) {
|
| state.warnings.push(`${slideName} has no content`);
|
| }
|
| });
|
|
|
|
|
| if (state.totalDuration > 600) {
|
| state.warnings.push(`Total duration is ${formatDuration(state.totalDuration)} (over 10 minutes) - consider shorter presentation`);
|
| }
|
| }
|
|
|
| function showDiagnostics() {
|
| if (state.errors.length === 0 && state.warnings.length === 0) {
|
| dom.markdownDiagnostics.classList.add('hidden');
|
| return;
|
| }
|
|
|
| const messages = [
|
| ...state.errors.map(e => `[ERROR] ${e}`),
|
| ...state.warnings.map(w => `[WARN] ${w}`)
|
| ];
|
|
|
| dom.markdownDiagnostics.innerHTML = messages.join('<br>');
|
| dom.markdownDiagnostics.classList.remove('hidden');
|
| }
|
|
|
| function updateMarkdownSummary() {
|
| dom.markdownSummary.innerHTML = `
|
| <strong>Slides:</strong> ${state.slides.length} |
|
| <strong>Duration:</strong> ${formatDuration(state.totalDuration)} |
|
| <strong>Template:</strong> ${state.template}
|
| `;
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function updateTimelineUI() {
|
| dom.timelineTotal.textContent = formatDuration(state.totalDuration);
|
|
|
| let currentTime = 0;
|
| const sceneHTML = state.slides.map((slide, i) => {
|
| const startTime = currentTime;
|
| const endTime = currentTime + slide.duration;
|
| currentTime = endTime;
|
|
|
|
|
| const pageInfo = slide.totalPages > 1
|
| ? `<span class="timeline-page-indicator">Page ${slide.pageNumber}/${slide.totalPages}</span>`
|
| : '';
|
|
|
|
|
| const linesInfo = slide.visualLines
|
| ? `<span class="text-xs opacity-60">${Math.round(slide.visualLines)} lines</span>`
|
| : '';
|
|
|
| const titleText = (slide.title || '').trim();
|
| const slideLabel = titleText
|
| ? `Slide ${i + 1} - ${escapeHtml(titleText)}`
|
| : `Slide ${i + 1}`;
|
|
|
| return `
|
| <div class="py-3 flex flex-col gap-1">
|
| <div class="flex items-center justify-between text-sm text-slate-200">
|
| <div class="flex items-center gap-2">
|
| <span>${slideLabel}</span>
|
| ${pageInfo}
|
| </div>
|
| <span>${slide.duration}s</span>
|
| </div>
|
| <div class="flex items-center justify-between">
|
| <p class="text-xs text-slate-500">
|
| ${formatTimecode(startTime)} to ${formatTimecode(endTime)}
|
| </p>
|
| ${linesInfo}
|
| </div>
|
| </div>
|
| `;
|
| }).join('<div class="border-t border-slate-800"></div>');
|
|
|
| dom.timelineSceneList.innerHTML = sceneHTML || '<p class="text-slate-500 text-sm">No slides yet</p>';
|
| updateAssetChecklist();
|
| }
|
|
|
| function updateAssetChecklist() {
|
| const assets = [];
|
| state.slides.forEach(slide => {
|
| const items = slide.renderItems || slide.content || [];
|
| items.forEach(item => {
|
| if (item.type === 'image') {
|
| assets.push({ path: item.src, status: 'pending' });
|
| }
|
| });
|
| });
|
|
|
| if (assets.length === 0) {
|
| dom.assetChecklist.innerHTML = '<li class="text-slate-500">No assets referenced</li>';
|
| return;
|
| }
|
|
|
| const assetHTML = assets.map(asset => `
|
| <li class="flex items-center justify-between">
|
| <span>${escapeHtml(asset.path)}</span>
|
| <span class="status-pill ${asset.status}">${asset.status}</span>
|
| </li>
|
| `).join('');
|
| dom.assetChecklist.innerHTML = assetHTML;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function getStagePreviewData(slides, totalDuration) {
|
| if (!slides || slides.length === 0) {
|
| return null;
|
| }
|
|
|
| const firstSlide = slides[0];
|
| const lastSlide = slides[slides.length - 1];
|
|
|
| let currentTime = 0;
|
| const timelineItems = slides.slice(0, 3).map((slide, index) => {
|
| const slideTitle = slide.title || 'Untitled Slide';
|
| const startTime = currentTime;
|
| const endTime = currentTime + slide.duration;
|
| currentTime = endTime;
|
|
|
| return {
|
| label: `Slide ${index + 1} - ${slideTitle}`,
|
| startTime,
|
| endTime
|
| };
|
| });
|
|
|
| return {
|
| intro: {
|
| title: firstSlide.title || 'Untitled Slide',
|
| subtitle: firstSlide.subtitle || 'Markdown Video Studio'
|
| },
|
| outro: {
|
| title: lastSlide.title || 'Thank You',
|
| tagline: `${slides.length} slides - ${formatDuration(totalDuration)}`
|
| },
|
| timelineItems
|
| };
|
| }
|
|
|
| |
| |
| |
|
|
| function renderStagePreview(previewData) {
|
| if (!previewData) return;
|
|
|
| const introTitle = document.querySelector('[data-bind="intro.title"]');
|
| const introSubtitle = document.querySelector('[data-bind="intro.subtitle"]');
|
| if (introTitle) introTitle.textContent = previewData.intro.title;
|
| if (introSubtitle) introSubtitle.textContent = previewData.intro.subtitle;
|
|
|
| const outroTitle = document.querySelector('[data-bind="outro.title"]');
|
| const outroTagline = document.querySelector('[data-bind="outro.tagline"]');
|
| if (outroTitle) outroTitle.textContent = previewData.outro.title;
|
| if (outroTagline) outroTagline.textContent = previewData.outro.tagline;
|
|
|
| const timelinePreview = document.getElementById('timelinePreview');
|
| if (!timelinePreview) return;
|
|
|
| const previewHTML = previewData.timelineItems.map(item => (
|
| `
|
| <li class="flex items-start justify-between gap-3">
|
| <span class="font-semibold">${escapeHtml(item.label)}</span>
|
| <span class="opacity-70">${formatTimecode(item.startTime)} to ${formatTimecode(item.endTime)}</span>
|
| </li>
|
| `
|
| )).join('');
|
|
|
| timelinePreview.innerHTML = previewHTML;
|
| }
|
|
|
| function updateStagePreview() {
|
| if (state.slides.length === 0) return;
|
|
|
| const previewData = getStagePreviewData(state.slides, state.totalDuration);
|
| renderStagePreview(previewData);
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupConfigInputs() {
|
| const resSelect = document.querySelector('[data-config="video.resolution"]');
|
| if (resSelect) {
|
| resSelect.addEventListener('change', (e) => {
|
| state.videoConfig.resolution = e.target.value;
|
| upsertFrontmatterValue('video.resolution', e.target.value);
|
| });
|
| }
|
|
|
| const fpsSelect = document.querySelector('[data-config="video.fps"]');
|
| if (fpsSelect) {
|
| fpsSelect.addEventListener('change', (e) => {
|
| state.videoConfig.fps = parseInt(e.target.value);
|
| upsertFrontmatterValue('video.fps', e.target.value);
|
| });
|
| }
|
|
|
| const qualitySlider = document.querySelector('[data-config="video.quality"]');
|
| const qualityValue = document.getElementById('qualityValue');
|
| if (qualitySlider) {
|
| qualitySlider.addEventListener('input', (e) => {
|
| const value = parseFloat(e.target.value);
|
| state.videoConfig.quality = value;
|
| if (qualityValue) qualityValue.textContent = Math.round(value * 100) + '%';
|
| upsertFrontmatterValue('video.quality', value.toFixed(2));
|
| });
|
| }
|
|
|
| const accentInput = document.querySelector('[data-config="theme.accent"]');
|
| if (accentInput) {
|
| accentInput.addEventListener('input', (e) => {
|
| state.themeConfig.accent = e.target.value;
|
| document.documentElement.style.setProperty('--accent-color', e.target.value);
|
| upsertFrontmatterValue('theme.accent', e.target.value);
|
| });
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupExportControls() {
|
| dom.previewBtn.addEventListener('click', previewTimeline);
|
| dom.recordWebMBtn.addEventListener('click', exportVideo);
|
| dom.resetBtn.addEventListener('click', resetApplication);
|
| dom.securityBtn.addEventListener('click', showSecurityStats);
|
|
|
|
|
| if (dom.stopPreviewBtn) {
|
| dom.stopPreviewBtn.addEventListener('click', () => {
|
| stopPreview();
|
| });
|
| }
|
|
|
| if (dom.stopExportBtn) {
|
| dom.stopExportBtn.addEventListener('click', () => {
|
|
|
| state.isExporting = false;
|
| if (dom.stopExportBtn) dom.stopExportBtn.classList.add('hidden');
|
| });
|
| }
|
|
|
| const rendererBackend = document.getElementById('rendererBackend');
|
| if (rendererBackend) {
|
| rendererBackend.textContent = 'MediaRecorder (WebM)';
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupConfigManagement() {
|
|
|
| const exportConfigBtn = document.getElementById('exportConfigBtn');
|
| if (exportConfigBtn) {
|
| exportConfigBtn.addEventListener('click', async () => {
|
| try {
|
| await exportConfigToFile();
|
| setStatus('Config exported successfully', 'online');
|
| } catch (error) {
|
| console.error('[App] Failed to export config:', error);
|
| setStatus('Failed to export config', 'error');
|
| }
|
| });
|
| }
|
|
|
|
|
| const importConfigBtn = document.getElementById('importConfigBtn');
|
| if (importConfigBtn) {
|
| importConfigBtn.addEventListener('click', async () => {
|
| try {
|
| const result = await importConfigFromFile();
|
| if (result) {
|
| setStatus('Config imported and applied successfully', 'online');
|
|
|
| reloadUI();
|
| }
|
| } catch (error) {
|
| console.error('[App] Failed to import config:', error);
|
| setStatus('Failed to import config', 'error');
|
| }
|
| });
|
| }
|
|
|
|
|
| const resetConfigBtn = document.getElementById('resetConfigBtn');
|
| if (resetConfigBtn) {
|
| resetConfigBtn.addEventListener('click', () => {
|
| if (confirm('Reset all settings to default? This will clear your saved configuration.')) {
|
| resetConfig(true);
|
| reloadUI();
|
| setStatus('Configuration reset to defaults', 'online');
|
| }
|
| });
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupPresentationMode() {
|
|
|
| if (dom.presentationModeBtn) {
|
| dom.presentationModeBtn.addEventListener('click', startPresentationMode);
|
| }
|
|
|
|
|
| if (dom.exitPresentationBtn) {
|
| dom.exitPresentationBtn.addEventListener('click', () => {
|
| exitPresentationMode();
|
| });
|
| }
|
|
|
|
|
| if (dom.prevSlideBtn) {
|
| dom.prevSlideBtn.addEventListener('click', gotoPreviousSlide);
|
| }
|
|
|
| if (dom.nextSlideBtn) {
|
| dom.nextSlideBtn.addEventListener('click', gotoNextSlide);
|
| }
|
|
|
|
|
| document.addEventListener('keydown', (e) => {
|
| if (!state.isPresentationMode) return;
|
|
|
|
|
| if ((slideEditor.isEditMode || slideEditor.isDragMode) && e.code !== 'Escape') {
|
| return;
|
| }
|
|
|
| if (e.code === 'ArrowLeft') {
|
| e.preventDefault();
|
| gotoPreviousSlide();
|
| } else if (e.code === 'ArrowRight' || e.code === 'Space') {
|
| e.preventDefault();
|
| gotoNextSlide();
|
| } else if (e.code === 'Escape') {
|
| e.preventDefault();
|
| exitPresentationMode();
|
| } else if (e.code === 'Home') {
|
| e.preventDefault();
|
| gotoSlide(0);
|
| } else if (e.code === 'End') {
|
| e.preventDefault();
|
| gotoSlide(state.slides.length - 1);
|
| } else if (e.code === 'KeyE') {
|
|
|
| e.preventDefault();
|
| slideEditor.toggleEditMode();
|
| } else if (e.code === 'KeyD') {
|
|
|
| e.preventDefault();
|
| slideEditor.toggleDragMode();
|
| }
|
| });
|
| }
|
|
|
| async function startPresentationMode() {
|
| if (state.slides.length === 0) {
|
| setStatus('No slides - sync markdown first', 'online');
|
| return;
|
| }
|
|
|
|
|
|
|
| switchToPresentationMode();
|
|
|
| state.isPresentationMode = true;
|
| state.currentSlideIndex = 0;
|
|
|
|
|
|
|
|
|
| slideEditor.setCurrentSlide(0);
|
|
|
|
|
| setControlsDisabled(true);
|
|
|
|
|
| detectScreenSize();
|
| gotoSlideWithSmartLayout(0);
|
|
|
| setStatus('Presentation Mode - Use arrow keys to navigate, ESC to exit', 'online');
|
| }
|
|
|
| function exitPresentationMode() {
|
| state.isPresentationMode = false;
|
| state.currentSlideIndex = 0;
|
|
|
|
|
|
|
| switchToIntroMode();
|
|
|
|
|
|
|
|
|
| slideEditor.reset();
|
|
|
|
|
| if (document.fullscreenElement || document.webkitFullscreenElement) {
|
| exitFullscreen();
|
| }
|
|
|
|
|
| setControlsDisabled(false);
|
|
|
|
|
| showScene('intro');
|
|
|
| setStatus('Exited presentation mode', 'online');
|
| }
|
|
|
| function gotoSlide(index) {
|
| if (index < 0 || index >= state.slides.length) return;
|
|
|
| state.currentSlideIndex = index;
|
|
|
|
|
| slideEditor.setCurrentSlide(index);
|
|
|
| if (state.isPresentationMode) {
|
| gotoSlideWithSmartLayout(index);
|
| return;
|
| }
|
|
|
| const slide = state.slides[index];
|
|
|
| renderSlideToStage(slide);
|
| showScene('body');
|
|
|
| updateSlideCounter();
|
| updateNavigationButtons();
|
| }
|
|
|
| function gotoPreviousSlide() {
|
| if (state.currentSlideIndex > 0) {
|
| gotoSlide(state.currentSlideIndex - 1);
|
| }
|
| }
|
|
|
| function gotoNextSlide() {
|
| if (state.currentSlideIndex < state.slides.length - 1) {
|
| gotoSlide(state.currentSlideIndex + 1);
|
| }
|
| }
|
|
|
| function updateSlideCounter() {
|
| if (dom.slideCounter) {
|
| dom.slideCounter.textContent = `${state.currentSlideIndex + 1} / ${state.slides.length}`;
|
| }
|
| }
|
|
|
| function updateNavigationButtons() {
|
|
|
| if (dom.prevSlideBtn) {
|
| dom.prevSlideBtn.disabled = state.currentSlideIndex === 0;
|
| }
|
|
|
|
|
| if (dom.nextSlideBtn) {
|
| dom.nextSlideBtn.disabled = state.currentSlideIndex === state.slides.length - 1;
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupFullscreenControl() {
|
| if (dom.fullscreenBtn) {
|
| dom.fullscreenBtn.addEventListener('click', toggleFullscreen);
|
| }
|
|
|
|
|
| document.addEventListener('fullscreenchange', onFullscreenChange);
|
| document.addEventListener('webkitfullscreenchange', onFullscreenChange);
|
| document.addEventListener('mozfullscreenchange', onFullscreenChange);
|
| document.addEventListener('MSFullscreenChange', onFullscreenChange);
|
|
|
|
|
| document.addEventListener('keydown', (e) => {
|
| if (e.code === 'KeyF' && state.isPresentationMode) {
|
| e.preventDefault();
|
| toggleFullscreen();
|
| }
|
| });
|
| }
|
|
|
| function toggleFullscreen() {
|
| if (!document.fullscreenElement && !document.webkitFullscreenElement) {
|
| enterFullscreen();
|
| } else {
|
| exitFullscreen();
|
| }
|
| }
|
|
|
| function enterFullscreen() {
|
| const element = dom.stageFrame;
|
|
|
| if (element.requestFullscreen) {
|
| element.requestFullscreen();
|
| } else if (element.webkitRequestFullscreen) {
|
| element.webkitRequestFullscreen();
|
| } else if (element.mozRequestFullScreen) {
|
| element.mozRequestFullScreen();
|
| } else if (element.msRequestFullscreen) {
|
| element.msRequestFullscreen();
|
| }
|
| }
|
|
|
| function exitFullscreen() {
|
| if (document.exitFullscreen) {
|
| document.exitFullscreen();
|
| } else if (document.webkitExitFullscreen) {
|
| document.webkitExitFullscreen();
|
| } else if (document.mozCancelFullScreen) {
|
| document.mozCancelFullScreen();
|
| } else if (document.msExitFullscreen) {
|
| document.msExitFullscreen();
|
| }
|
| }
|
|
|
| function onFullscreenChange() {
|
| const isFullscreen = !!(document.fullscreenElement || document.webkitFullscreenElement);
|
|
|
|
|
| if (dom.fullscreenBtn) {
|
| const icon = dom.fullscreenBtn.querySelector('.fullscreen-icon');
|
| if (icon) {
|
| icon.textContent = isFullscreen ? '⛶' : '⛶';
|
| }
|
| }
|
|
|
| if (state.isPresentationMode) {
|
| detectScreenSize();
|
| gotoSlideWithSmartLayout(state.currentSlideIndex);
|
|
|
|
|
| if (slideEditor.isDragMode) {
|
| slideEditor.dragDropManager.updateSafeZoneBorders();
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function setupScreenSensor() {
|
| ensureMeasurementStage();
|
| detectScreenSize();
|
|
|
| window.addEventListener('resize', debounce(() => {
|
| ensureMeasurementStage();
|
| detectScreenSize();
|
| if (state.isPresentationMode) {
|
| gotoSlideWithSmartLayout(state.currentSlideIndex);
|
| }
|
| }, 200));
|
|
|
| if (window.screen && window.screen.orientation && typeof window.screen.orientation.addEventListener === 'function') {
|
| window.screen.orientation.addEventListener('change', () => {
|
| ensureMeasurementStage();
|
| detectScreenSize();
|
| if (state.isPresentationMode) {
|
| gotoSlideWithSmartLayout(state.currentSlideIndex);
|
| }
|
| });
|
| }
|
| }
|
|
|
| function detectScreenSize() {
|
| const width = window.innerWidth;
|
| const height = window.innerHeight;
|
| const pixelRatio = window.devicePixelRatio || 1;
|
| const isFullscreen = !!(document.fullscreenElement || document.webkitFullscreenElement);
|
| const availableSpace = width * height;
|
|
|
| let screenType = 'normal';
|
| let isLargeScreen = false;
|
|
|
| if (availableSpace >= 3840000 || width >= 2560 || isFullscreen) {
|
| screenType = 'ultra';
|
| isLargeScreen = true;
|
| } else if (availableSpace >= 2073600 || width >= 1920) {
|
| screenType = 'large';
|
| isLargeScreen = true;
|
| }
|
|
|
| const previousType = state.screenSensor.screenType;
|
| state.screenSensor = {
|
| width,
|
| height,
|
| pixelRatio,
|
| isLargeScreen,
|
| screenType,
|
| isFullscreen,
|
| availableSpace,
|
| lastUpdate: Date.now()
|
| };
|
|
|
| const stage = dom.stage || document.getElementById('stage');
|
| if (stage) {
|
| stage.classList.remove('screen-normal', 'screen-large', 'screen-ultra');
|
| stage.classList.add(`screen-${screenType}`);
|
| updateMeasurementStageSize();
|
| }
|
|
|
| if (previousType !== screenType) {
|
| console.log(`[SmartLayout] Screen changed: ${previousType} -> ${screenType} (${width}x${height})`);
|
| }
|
|
|
| return state.screenSensor;
|
| }
|
|
|
| function buildSlideItemHtml(item, { isPreview = false } = {}) {
|
| const previewClass = isPreview ? 'preview-block' : '';
|
| const previewAttr = isPreview ? ' data-preview="true"' : '';
|
| const blockAttr = item.layoutBlockId ? ` data-block-id="${item.layoutBlockId}"` : '';
|
| const sectionAttr = item.sectionId ? ` data-section-id="${item.sectionId}"` : '';
|
| const listAttr = item.listId ? ` data-list-id="${item.listId}"` : '';
|
| const dataAttrs = `${previewAttr}${blockAttr}${sectionAttr}${listAttr}`;
|
| const language = item.language || '';
|
|
|
| switch (item.type) {
|
| case 'h1':
|
| return `<h1 class="slide-heading slide-h1 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h1>`;
|
| case 'h2':
|
| return `<h2 class="slide-heading slide-h2 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h2>`;
|
| case 'h3':
|
| return `<h3 class="slide-heading slide-h3 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h3>`;
|
| case 'h4':
|
| return `<h4 class="slide-heading slide-h4 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h4>`;
|
| case 'h5':
|
| return `<h5 class="slide-heading slide-h5 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h5>`;
|
| case 'h6':
|
| return `<h6 class="slide-heading slide-h6 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</h6>`;
|
| case 'list-item': {
|
| const marker = item.marker || '•';
|
| return `<li class="slide-list-item ${previewClass}"${dataAttrs}>${escapeHtml(marker)} ${item.html ?? escapeHtml(item.content)}</li>`;
|
| }
|
| case 'numbered-item': {
|
| const numberLabel = item.number != null ? `${item.number}.` : '';
|
| const prefix = numberLabel ? `${escapeHtml(numberLabel)} ` : '';
|
| return `<li class="slide-list-item ${previewClass}"${dataAttrs}>${prefix}${item.html ?? escapeHtml(item.content)}</li>`;
|
| }
|
| case 'task-list': {
|
| const checkbox = item.checked ? '☑' : '☐';
|
| return `<li class="slide-list-item ${previewClass}"${dataAttrs}>${escapeHtml(checkbox)} ${item.html ?? escapeHtml(item.content)}</li>`;
|
| }
|
| case 'text': {
|
| const textClass = isPreview ? 'slide-text slide-text-preview' : 'slide-text';
|
| return `<p class="${textClass} ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content)}</p>`;
|
| }
|
| case 'code':
|
| return `<div class="relative slide-code ${previewClass}"${dataAttrs}><pre class="code-block"><code class="language-${language}">${escapeHtml(item.content)}</code></pre></div>`;
|
| case 'blockquote':
|
| return `<blockquote class="slide-blockquote ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content || '')}</blockquote>`;
|
| case 'image': {
|
| const title = item.title ? `title="${escapeHtml(item.title)}"` : '';
|
| return `<img src="${escapeHtml(item.src)}" alt="${escapeHtml(item.alt)}" ${title} class="slide-image ${previewClass}"${dataAttrs} />`;
|
| }
|
| case 'link': {
|
| const linkTitle = item.title ? `title="${escapeHtml(item.title)}"` : '';
|
| return `<a href="${escapeHtml(item.url)}" ${linkTitle} class="slide-link ${previewClass}"${dataAttrs}>${escapeHtml(item.text)}</a>`;
|
| }
|
| case 'table': {
|
| let html = `<div class="relative ${previewClass}"${dataAttrs}>`;
|
| html += '<table class="slide-table">';
|
| if (item.rows && item.rows.length > 0) {
|
| html += '<thead><tr>';
|
| item.rows[0].forEach(cell => {
|
| html += `<th>${escapeHtml(cell)}</th>`;
|
| });
|
| html += '</tr></thead>';
|
|
|
| if (item.rows.length > 2) {
|
| html += '<tbody>';
|
| for (let i = 2; i < item.rows.length; i++) {
|
| html += '<tr>';
|
| item.rows[i].forEach(cell => {
|
| html += `<td>${escapeHtml(cell)}</td>`;
|
| });
|
| html += '</tr>';
|
| }
|
| html += '</tbody>';
|
| }
|
| }
|
| html += '</table>';
|
| html += '</div>';
|
| return html;
|
| }
|
| case 'hr':
|
| return `<hr class="slide-hr ${previewClass}"${dataAttrs} />`;
|
| case 'html':
|
| return `<div class="html-content ${previewClass}"${dataAttrs}>${item.html ?? item.content ?? ''}</div>`;
|
| default:
|
| return `<p class="text-2xl mb-2 ${previewClass}"${dataAttrs}>${item.html ?? escapeHtml(item.content || '')}</p>`;
|
| }
|
| }
|
|
|
| function htmlToNode(html) {
|
| const template = document.createElement('template');
|
| template.innerHTML = html.trim();
|
| return template.content.firstElementChild;
|
| }
|
|
|
| function getSmartSlideBlocks(slides, startIndex, screenType) {
|
| if (!Array.isArray(slides) || startIndex < 0 || startIndex >= slides.length) {
|
| return [];
|
| }
|
|
|
| const candidates = [];
|
| const maxSlidesToConsider = screenType === 'ultra'
|
| ? 4
|
| : screenType === 'large'
|
| ? 3
|
| : 2;
|
|
|
| const upperBound = Math.min(slides.length, startIndex + maxSlidesToConsider);
|
|
|
| for (let slideIndex = startIndex; slideIndex < upperBound; slideIndex += 1) {
|
| const slide = slides[slideIndex];
|
| if (!slide) continue;
|
|
|
| const isPreviewSlide = slideIndex !== startIndex;
|
| const sourceItems = slide.renderItems || slide.content || [];
|
|
|
| sourceItems.forEach((originalItem, itemIndex) => {
|
| if (isPreviewSlide && /^h[1-6]$/.test(originalItem.type || '')) {
|
| return;
|
| }
|
|
|
| const block = { ...originalItem };
|
|
|
| if (isPreviewSlide) {
|
| block.isPreview = true;
|
| block.fromNextSlide = true;
|
| block.previewSourceIndex = slideIndex;
|
| block.previewItemIndex = itemIndex;
|
| }
|
|
|
| candidates.push(block);
|
| });
|
| }
|
|
|
| return candidates;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function prepareSmartSlideContent(slides, startIndex, screenType) {
|
| const measurementRoot = ensureMeasurementStage();
|
| if (!measurementRoot || !Array.isArray(slides) || startIndex < 0 || startIndex >= slides.length) {
|
| const fallbackSlide = slides?.[startIndex];
|
| return fallbackSlide?.renderItems || fallbackSlide?.content || [];
|
| }
|
|
|
| const stageRect = dom.stage
|
| ? dom.stage.getBoundingClientRect()
|
| : dom.stageFrame
|
| ? dom.stageFrame.getBoundingClientRect()
|
| : getSmartLayoutStageFallback();
|
|
|
| const safeZoneInsets = computeSafeZoneInsets(stageRect);
|
| applySafeZonePadding(dom.measurementRoot, safeZoneInsets);
|
|
|
| const usableHeight = Math.max(stageRect.height - safeZoneInsets.top - safeZoneInsets.bottom, 0);
|
| const heightBudget = usableHeight > 0 ? usableHeight : stageRect.height;
|
| const maxHeight = heightBudget * getSmartLayoutFillRatio();
|
|
|
| const candidates = getSmartSlideBlocks(slides, startIndex, screenType);
|
| if (!candidates.length) {
|
| const fallbackSlide = slides[startIndex];
|
| return fallbackSlide?.renderItems || fallbackSlide?.content || [];
|
| }
|
|
|
| const selectedItems = [];
|
|
|
| for (let index = 0; index < candidates.length; index += 1) {
|
| const originalBlock = candidates[index];
|
| const block = { ...originalBlock };
|
| const itemHtml = buildSlideItemHtml(block, { isPreview: !!block.isPreview });
|
| const node = htmlToNode(itemHtml);
|
|
|
| if (!node) {
|
| continue;
|
| }
|
|
|
| measurementRoot.appendChild(node);
|
| const measuredHeight = dom.measurementRoot.getBoundingClientRect().height;
|
| const contentHeight = Math.max(measuredHeight - safeZoneInsets.top - safeZoneInsets.bottom, 0);
|
| const canFit = contentHeight <= maxHeight;
|
| const forceInclude = selectedItems.length === 0;
|
|
|
| if (canFit || forceInclude) {
|
| selectedItems.push(block);
|
| } else {
|
| measurementRoot.removeChild(node);
|
| break;
|
| }
|
| }
|
|
|
| measurementRoot.innerHTML = '';
|
|
|
| if (selectedItems.length === 0) {
|
| const fallbackSlide = slides[startIndex];
|
| return [...(fallbackSlide?.renderItems || fallbackSlide?.content || [])];
|
| }
|
|
|
| return selectedItems;
|
| }
|
|
|
| function gotoSlideWithSmartLayout(index) {
|
| if (index < 0 || index >= state.slides.length) return;
|
|
|
| const { screenType } = state.screenSensor;
|
| const baseSlide = state.slides[index];
|
|
|
| let itemsToRender = baseSlide.renderItems || baseSlide.content || [];
|
| if (screenType === 'large' || screenType === 'ultra') {
|
| itemsToRender = prepareSmartSlideContent(state.slides, index, screenType);
|
| }
|
|
|
| renderSlideToStage(baseSlide, itemsToRender);
|
|
|
|
|
| const activeScene = dom.stage.querySelector('.scene.active');
|
| if (activeScene) {
|
| const hasOverrides = slideEditor.applyOverrides(index, activeScene);
|
| if (hasOverrides) {
|
| console.log(`[App] Applied slide edits for slide ${index}`);
|
| }
|
|
|
|
|
| const hasPositions = slideEditor.applyPositions(index, activeScene);
|
| if (hasPositions) {
|
| console.log(`[App] Applied position overrides for slide ${index}`);
|
| }
|
| }
|
|
|
| showScene('body');
|
|
|
| updateSlideCounter();
|
| updateNavigationButtons();
|
|
|
| const scheduleBoundsCheck = () => ensureContentWithinBounds();
|
| if (typeof requestAnimationFrame === 'function') {
|
| requestAnimationFrame(scheduleBoundsCheck);
|
| } else {
|
| setTimeout(scheduleBoundsCheck, 0);
|
| }
|
| }
|
|
|
| let smartLayoutResizeObserver = null;
|
| let smartLayoutMutationObserver = null;
|
| let smartLayoutResizeFrame = null;
|
|
|
| function ensureContentWithinBounds() {
|
|
|
| const modeManager = getModeManager();
|
| if (modeManager && !modeManager.isSystemActive('smartLayout')) {
|
|
|
| return;
|
| }
|
|
|
| const stage = dom.stage;
|
| if (!stage) return;
|
|
|
| const root = stage.querySelector('.smart-layout-root');
|
| if (!root) return;
|
|
|
| root.style.transform = '';
|
| root.style.transformOrigin = '';
|
| root.style.width = '';
|
|
|
| const stageRect = stage.getBoundingClientRect();
|
| const contentRect = root.getBoundingClientRect();
|
|
|
| if (!stageRect.height || !contentRect.height) return;
|
|
|
|
|
| const safeZoneMargins = computeSafeZoneMargins(stageRect);
|
| const safeTop = safeZoneMargins.top || 0;
|
| const safeBottom = safeZoneMargins.bottom || 0;
|
| const safeLeft = safeZoneMargins.left || 0;
|
| const safeRight = safeZoneMargins.right || 0;
|
|
|
| const usableHeight = Math.max(stageRect.height - safeTop - safeBottom, 0);
|
| const usableWidth = Math.max(stageRect.width - safeLeft - safeRight, 0);
|
|
|
| if (usableHeight > 0 && contentRect.height <= usableHeight * 0.97) {
|
| return;
|
| }
|
|
|
| const heightTarget = usableHeight > 0 ? usableHeight : stageRect.height;
|
| if (!heightTarget) {
|
| return;
|
| }
|
|
|
| const scale = (heightTarget * 0.94) / contentRect.height;
|
| if (scale >= 1) {
|
| return;
|
| }
|
|
|
| root.style.transform = `scale(${scale})`;
|
| root.style.transformOrigin = 'top left';
|
|
|
| const widthTarget = usableWidth > 0 ? usableWidth : stageRect.width || stage.offsetWidth;
|
| if (widthTarget) {
|
| root.style.width = `${widthTarget / scale}px`;
|
| }
|
| }
|
|
|
| function attachSmartLayoutObservers(layoutRoot) {
|
| if (smartLayoutResizeObserver) {
|
| smartLayoutResizeObserver.disconnect();
|
| smartLayoutResizeObserver = null;
|
| }
|
| if (smartLayoutMutationObserver) {
|
| smartLayoutMutationObserver.disconnect();
|
| smartLayoutMutationObserver = null;
|
| }
|
| if (smartLayoutResizeFrame) {
|
| cancelAnimationFrame(smartLayoutResizeFrame);
|
| smartLayoutResizeFrame = null;
|
| }
|
|
|
| if (!layoutRoot) {
|
| return;
|
| }
|
|
|
| const scheduleBoundsCheck = () => {
|
| if (smartLayoutResizeFrame) {
|
| cancelAnimationFrame(smartLayoutResizeFrame);
|
| }
|
| smartLayoutResizeFrame = requestAnimationFrame(() => {
|
| smartLayoutResizeFrame = null;
|
| ensureContentWithinBounds();
|
| });
|
| };
|
|
|
| if (typeof ResizeObserver === 'function') {
|
| smartLayoutResizeObserver = new ResizeObserver(() => scheduleBoundsCheck());
|
| smartLayoutResizeObserver.observe(layoutRoot);
|
| if (dom.stage) {
|
| smartLayoutResizeObserver.observe(dom.stage);
|
| }
|
| }
|
|
|
| if (typeof MutationObserver === 'function') {
|
| smartLayoutMutationObserver = new MutationObserver(() => scheduleBoundsCheck());
|
| smartLayoutMutationObserver.observe(layoutRoot, {
|
| childList: true,
|
| subtree: true,
|
| characterData: true
|
| });
|
| }
|
|
|
| scheduleBoundsCheck();
|
| }
|
|
|
| |
| |
|
|
| function detachSmartLayoutObservers() {
|
| if (smartLayoutResizeObserver) {
|
| smartLayoutResizeObserver.disconnect();
|
| smartLayoutResizeObserver = null;
|
| }
|
| if (smartLayoutMutationObserver) {
|
| smartLayoutMutationObserver.disconnect();
|
| smartLayoutMutationObserver = null;
|
| }
|
| if (smartLayoutResizeFrame) {
|
| cancelAnimationFrame(smartLayoutResizeFrame);
|
| smartLayoutResizeFrame = null;
|
| }
|
| console.log('[SmartLayout] Observers detached');
|
| }
|
|
|
| |
| |
|
|
| function reattachSmartLayoutObservers() {
|
| const activeScene = dom.stage?.querySelector('.scene.active');
|
| const layoutRoot = activeScene?.querySelector('.smart-layout-root');
|
| if (layoutRoot) {
|
| attachSmartLayoutObservers(layoutRoot);
|
| console.log('[SmartLayout] Observers reattached');
|
| }
|
| }
|
|
|
|
|
| window.smartLayoutControl = {
|
| detach: detachSmartLayoutObservers,
|
| reattach: reattachSmartLayoutObservers
|
| };
|
|
|
| function debounce(func, wait) {
|
| let timeoutId;
|
| return function debounced(...args) {
|
| clearTimeout(timeoutId);
|
| timeoutId = setTimeout(() => func.apply(this, args), wait);
|
| };
|
| }
|
|
|
| |
| |
|
|
| function setupStageClickHandler() {
|
| if (!dom.stage) return;
|
|
|
|
|
| dom.stage.addEventListener('click', (e) => {
|
|
|
| if (!state.isPlaying || state.isPresentationMode) return;
|
| togglePause();
|
| });
|
|
|
|
|
| document.addEventListener('keydown', (e) => {
|
|
|
| if (state.isPresentationMode) return;
|
|
|
| if (!state.isPlaying) return;
|
|
|
| if (e.code === 'Space' || e.code === 'KeyP') {
|
| e.preventDefault();
|
| togglePause();
|
| }
|
|
|
|
|
| if (e.code === 'Escape') {
|
| e.preventDefault();
|
| stopPreview();
|
| }
|
| });
|
|
|
|
|
| dom.stage.style.cursor = 'pointer';
|
| dom.stage.title = 'Click to pause/resume preview (or press Space/P)';
|
| }
|
|
|
| |
| |
|
|
| function togglePause() {
|
| if (state.isPaused) {
|
|
|
| console.log('[App] Resuming preview...');
|
| state.isPaused = false;
|
| setStatus('Playing preview... (Click or Space to pause)', 'online');
|
|
|
|
|
| if (dom.pauseOverlay) {
|
| dom.pauseOverlay.classList.add('hidden');
|
| }
|
|
|
|
|
| if (state.pauseResolve) {
|
| state.pauseResolve();
|
| }
|
| } else {
|
|
|
| console.log('[App] Paused preview');
|
| state.isPaused = true;
|
| setStatus('Preview PAUSED - Click or Space to resume', 'warning');
|
|
|
|
|
| if (dom.pauseOverlay) {
|
| dom.pauseOverlay.classList.remove('hidden');
|
| }
|
| }
|
| }
|
|
|
| |
| |
|
|
| function stopPreview() {
|
| console.log('[App] Stopping preview...');
|
| state.isPlaying = false;
|
| state.isPaused = false;
|
|
|
|
|
| if (state.pauseResolve) {
|
| state.pauseResolve();
|
| state.pauseResolve = null;
|
| }
|
|
|
| setStatus('Preview stopped', 'online');
|
| }
|
|
|
| async function previewTimeline() {
|
| if (state.isPlaying) return;
|
| if (state.slides.length === 0) {
|
| setStatus('No slides - sync markdown first', 'online');
|
| return;
|
| }
|
|
|
| state.isPlaying = true;
|
| state.isPaused = false;
|
| setControlsDisabled(true);
|
|
|
|
|
| if (dom.stopPreviewBtn) dom.stopPreviewBtn.classList.remove('hidden');
|
|
|
| setStatus('Playing preview... (Click stage to pause)', 'online');
|
|
|
|
|
| if (dom.pauseOverlay) {
|
| dom.pauseOverlay.classList.add('hidden');
|
| }
|
|
|
| try {
|
| for (let i = 0; i < state.slides.length; i++) {
|
| state.currentSlideIndex = i;
|
| await playSlide(state.slides[i]);
|
|
|
|
|
| if (!state.isPlaying) break;
|
| }
|
| setStatus('Preview completed', 'online');
|
| } catch (error) {
|
| console.error('[App] Preview error:', error);
|
| setStatus('Preview error: ' + error.message, 'online');
|
| } finally {
|
| state.isPlaying = false;
|
| state.isPaused = false;
|
| state.pauseResolve = null;
|
| state.currentSlideIndex = 0;
|
| setControlsDisabled(false);
|
| showScene('intro');
|
|
|
|
|
| if (dom.stopPreviewBtn) dom.stopPreviewBtn.classList.add('hidden');
|
|
|
|
|
| if (dom.pauseOverlay) {
|
| dom.pauseOverlay.classList.add('hidden');
|
| }
|
| }
|
| }
|
|
|
| async function playSlide(slide) {
|
| console.log('[App] Playing:', slide.title, slide.duration + 's');
|
| renderSlideToStage(slide);
|
| showScene('body');
|
| await waitWithPause(slide.duration * 1000);
|
| }
|
|
|
| |
| |
|
|
| async function waitWithPause(duration) {
|
| const startTime = Date.now();
|
| let elapsed = 0;
|
|
|
| while (elapsed < duration) {
|
|
|
| if (state.isPaused) {
|
|
|
| await new Promise(resolve => {
|
| state.pauseResolve = resolve;
|
| });
|
|
|
| state.isPaused = false;
|
| state.pauseResolve = null;
|
| }
|
|
|
|
|
| const remainingTime = duration - elapsed;
|
| const waitTime = Math.min(100, remainingTime);
|
|
|
| await new Promise(resolve => setTimeout(resolve, waitTime));
|
|
|
| elapsed = Date.now() - startTime;
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| |
| |
|
|
| function renderSlideToStage(slide, itemsOverride = null) {
|
| const bodyScene = document.querySelector('[data-scene="body"]');
|
| if (!bodyScene) return;
|
|
|
| const stageRect = dom.stage
|
| ? dom.stage.getBoundingClientRect()
|
| : dom.stageFrame
|
| ? dom.stageFrame.getBoundingClientRect()
|
| : getSmartLayoutStageFallback();
|
|
|
| const safeZoneInsets = computeSafeZoneInsets(stageRect);
|
|
|
| const htmlParts = ['<div class="smart-layout-root relative z-10 space-y-4">'];
|
|
|
| if (slide.totalPages > 1) {
|
| htmlParts.push(`<div class="slide-page-indicator">
|
| <span>
|
| ${slide.pageNumber} / ${slide.totalPages}
|
| </span>
|
| </div>`);
|
| }
|
|
|
| const isListType = (type) => type === 'list-item' || type === 'numbered-item' || type === 'task-list';
|
| let listBuffer = null;
|
|
|
| const flushListBuffer = () => {
|
| if (!listBuffer || listBuffer.items.length === 0) {
|
| listBuffer = null;
|
| return;
|
| }
|
|
|
| const classes = ['smart-list'];
|
| if (listBuffer.hasPreview) {
|
| classes.push('has-preview');
|
| }
|
|
|
| htmlParts.push(`<${listBuffer.tag} class="${classes.join(' ')}">`);
|
| listBuffer.items.forEach(itemHtml => htmlParts.push(itemHtml));
|
| htmlParts.push(`</${listBuffer.tag}>`);
|
| listBuffer = null;
|
| };
|
|
|
| const items = itemsOverride || slide.renderItems || slide.content || [];
|
|
|
| items.forEach(item => {
|
| const isPreview = !!(item.isPreview || item.fromNextSlide);
|
| const itemHtml = buildSlideItemHtml(item, { isPreview });
|
|
|
| if (isListType(item.type)) {
|
| const tag = item.type === 'numbered-item' ? 'ol' : 'ul';
|
|
|
| if (!listBuffer || listBuffer.tag !== tag) {
|
| flushListBuffer();
|
| listBuffer = { tag, items: [], hasPreview: false };
|
| }
|
|
|
| listBuffer.items.push(itemHtml);
|
| listBuffer.hasPreview = listBuffer.hasPreview || isPreview;
|
| } else {
|
| flushListBuffer();
|
| htmlParts.push(itemHtml);
|
| }
|
| });
|
|
|
| flushListBuffer();
|
|
|
| htmlParts.push('</div>');
|
| htmlParts.push('<div class="gradient-backdrop"></div>');
|
|
|
| bodyScene.innerHTML = htmlParts.join('');
|
| applySmartLayoutTransforms(bodyScene);
|
| const layoutRoot = bodyScene.querySelector('.smart-layout-root');
|
| applySafeZonePadding(layoutRoot, safeZoneInsets);
|
| attachSmartLayoutObservers(layoutRoot);
|
| }
|
|
|
| function applySmartLayoutTransforms(container) {
|
| const layoutRoot = container.querySelector('.smart-layout-root');
|
| if (!layoutRoot) return;
|
|
|
| enhanceSmartLists(layoutRoot);
|
| }
|
|
|
| function enhanceSmartLists(layoutRoot) {
|
| const lists = layoutRoot.querySelectorAll('.smart-list');
|
| if (!lists.length) return;
|
|
|
| const isLargeScreen = !!state.screenSensor?.isLargeScreen;
|
|
|
| lists.forEach(list => {
|
| list.classList.remove('smart-balanced', 'smart-balanced-three');
|
|
|
| if (!isLargeScreen) {
|
| return;
|
| }
|
|
|
| const items = Array.from(list.querySelectorAll('li'));
|
| const previewCount = items.filter(li => li.dataset.preview === 'true').length;
|
| const visibleCount = items.length - previewCount;
|
|
|
|
|
| const config = getCurrentConfig();
|
| const twoColumnThreshold = config?.smartList?.twoColumnThreshold || 6;
|
| const threeColumnThreshold = config?.smartList?.threeColumnThreshold || 12;
|
|
|
| if (visibleCount >= threeColumnThreshold) {
|
| list.classList.add('smart-balanced-three');
|
| } else if (visibleCount >= twoColumnThreshold) {
|
| list.classList.add('smart-balanced');
|
| }
|
| });
|
| }
|
|
|
| async function exportVideo() {
|
| if (state.slides.length === 0) {
|
| setStatus('No slides - sync markdown first', 'online');
|
| return;
|
| }
|
|
|
| const [width, height] = state.videoConfig.resolution.split('x').map(Number);
|
| const renderer = new VideoRenderer({
|
| width,
|
| height,
|
| fps: state.videoConfig.fps,
|
| quality: state.videoConfig.quality,
|
| format: 'webm'
|
| });
|
|
|
| setControlsDisabled(true);
|
| dom.progressContainer.classList.remove('hidden');
|
| setStatus('Recording video...', 'recording');
|
|
|
| try {
|
| await renderer.startRecording(dom.stage);
|
|
|
| for (let i = 0; i < state.slides.length; i++) {
|
| updateProgress(i, state.slides.length);
|
| await playSlide(state.slides[i]);
|
| }
|
|
|
| const result = await renderer.stopRecording();
|
| const base64 = await blobToBase64(result.blob);
|
| const filename = 'chahua-video-' + Date.now() + '.webm';
|
|
|
| const saveResult = await window.chahuaVideo.saveVideo({
|
| blob: base64,
|
| format: 'webm',
|
| filename
|
| });
|
|
|
| if (saveResult.success && !saveResult.canceled) {
|
| setStatus('Video saved: ' + saveResult.filePath + ' (' + formatBytes(saveResult.size) + ')', 'online');
|
| } else if (!saveResult.canceled) {
|
| setStatus('Save failed: ' + saveResult.error, 'online');
|
| } else {
|
| setStatus('Export canceled', 'online');
|
| }
|
| } catch (error) {
|
| console.error('[App] Export error:', error);
|
| setStatus('Export error: ' + error.message, 'online');
|
| } finally {
|
| setControlsDisabled(false);
|
| dom.progressContainer.classList.add('hidden');
|
| }
|
| }
|
|
|
| function updateProgress(current, total) {
|
| const percent = Math.round((current / total) * 100);
|
| dom.progressBar.style.width = percent + '%';
|
| dom.progressText.textContent = 'Recording slide ' + (current + 1) + ' of ' + total + '...';
|
| }
|
|
|
|
|
|
|
|
|
|
|
| async function loadSampleDeck() {
|
| const sampleMarkdown = `---
|
| template: modern
|
| video:
|
| resolution: 1920x1080
|
| fps: 60
|
| quality: 0.95
|
| theme:
|
| accent: #60a5fa
|
| ---
|
|
|
| # Introduction
|
| subtitle: Markdown Video Studio
|
| duration: 4
|
|
|
| Welcome to the new Markdown-first workflow.
|
|
|
| ---
|
|
|
| # Feature Highlights
|
| duration: 6
|
|
|
| - Native WebM encoding
|
| - Real-time preview
|
| - Frontmatter config sync
|
| - Offline-first architecture
|
|
|
| ---
|
|
|
| # Conclusion
|
| subtitle: Built with Electron + MediaRecorder
|
| duration: 5
|
|
|
| Thank you for watching!
|
| `;
|
| dom.markdownEditor.value = sampleMarkdown;
|
| syncMarkdown();
|
| setStatus('Sample deck loaded', 'online');
|
| }
|
|
|
| async function importMarkdownFile() {
|
| try {
|
| const result = await window.chahuaVideo.openMarkdownFile();
|
| if (result.success && !result.canceled) {
|
| dom.markdownEditor.value = result.content;
|
| syncMarkdown();
|
| setStatus('Loaded: ' + result.filePath, 'online');
|
| }
|
| } catch (error) {
|
| console.error('[App] Import error:', error);
|
| setStatus('Import failed: ' + error.message, 'online');
|
| }
|
| }
|
|
|
| async function openWorkspaceFolder() {
|
| try {
|
| const result = await window.chahuaVideo.openWorkspaceFolder();
|
| if (result.success) {
|
| setStatus('Opened workspace folder', 'online');
|
| }
|
| } catch (error) {
|
| console.error('[App] Workspace error:', error);
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| async function resetApplication() {
|
|
|
| const confirmed = confirm(
|
| 'Reset Application?\n\n' +
|
| 'This will:\n' +
|
| '• Clear all markdown content\n' +
|
| '• Reset all slides and timeline\n' +
|
| '• Reset to default template and settings\n' +
|
| '• Return to initial state\n\n' +
|
| 'This action cannot be undone.'
|
| );
|
|
|
| if (!confirmed) return;
|
|
|
| console.log('[App] Resetting application to initial state...');
|
|
|
|
|
| if (state.isPlaying) {
|
| state.isPlaying = false;
|
| if (state.pauseResolve) {
|
| state.pauseResolve();
|
| }
|
| }
|
|
|
| if (state.isPresentationMode) {
|
| exitPresentationMode();
|
| }
|
|
|
|
|
| state.markdown = '';
|
| state.frontmatter = {};
|
| state.slides = [];
|
| state.totalDuration = 0;
|
| state.template = 'modern';
|
| state.videoConfig = {
|
| resolution: '1920x1080',
|
| fps: 60,
|
| quality: 0.95
|
| };
|
| state.themeConfig = {
|
| accent: '#60a5fa'
|
| };
|
| state.isPlaying = false;
|
| state.isPaused = false;
|
| state.isPresentationMode = false;
|
| state.currentSlideIndex = 0;
|
| state.pauseResolve = null;
|
| state.errors = [];
|
| state.warnings = [];
|
|
|
|
|
| dom.markdownEditor.value = '';
|
|
|
|
|
| dom.markdownDiagnostics.classList.add('hidden');
|
|
|
|
|
| dom.markdownSummary.innerHTML = 'Awaiting markdown sync.';
|
|
|
|
|
| dom.timelineTotal.textContent = '00:00';
|
| dom.timelineSceneList.innerHTML = '<p class="text-slate-500 text-sm">No slides yet</p>';
|
|
|
|
|
| dom.assetChecklist.innerHTML = '<li class="text-slate-500">No assets referenced</li>';
|
|
|
|
|
| showScene('intro');
|
|
|
|
|
| const introTitle = document.querySelector('[data-bind="intro.title"]');
|
| const introSubtitle = document.querySelector('[data-bind="intro.subtitle"]');
|
| if (introTitle) introTitle.textContent = 'Markdown Video Studio';
|
| if (introSubtitle) introSubtitle.textContent = 'Define every slide, timing, and asset straight from your markdown deck.';
|
|
|
|
|
| const outroTitle = document.querySelector('[data-bind="outro.title"]');
|
| const outroTagline = document.querySelector('[data-bind="outro.tagline"]');
|
| if (outroTitle) outroTitle.textContent = 'Render from Markdown';
|
| if (outroTagline) outroTagline.textContent = 'Export consistent videos without ever leaving your markdown workflow.';
|
|
|
|
|
| const timelinePreview = document.getElementById('timelinePreview');
|
| if (timelinePreview) {
|
| timelinePreview.innerHTML = `
|
| <li class="flex items-start justify-between gap-3">
|
| <span class="font-semibold">Slide 1 · Intro</span>
|
| <span class="opacity-70">00:00 → 00:05</span>
|
| </li>
|
| <li class="flex items-start justify-between gap-3">
|
| <span class="font-semibold">Slide 2 · Agenda</span>
|
| <span class="opacity-70">00:05 → 00:15</span>
|
| </li>
|
| <li class="flex items-start justify-between gap-3">
|
| <span class="font-semibold">Slide 3 · Demo</span>
|
| <span class="opacity-70">00:15 → 00:35</span>
|
| </li>
|
| `;
|
| }
|
|
|
|
|
| applyTemplate('modern');
|
| updateTemplateUI();
|
|
|
|
|
| resetConfig();
|
| reloadUI(dom);
|
|
|
|
|
| document.querySelectorAll('.template-card').forEach((card, index) => {
|
| card.classList.toggle('active', index === 0);
|
| });
|
|
|
|
|
| const resSelect = document.querySelector('[data-config="video.resolution"]');
|
| if (resSelect) resSelect.value = '1920x1080';
|
|
|
| const fpsSelect = document.querySelector('[data-config="video.fps"]');
|
| if (fpsSelect) fpsSelect.value = '60';
|
|
|
| const qualitySlider = document.querySelector('[data-config="video.quality"]');
|
| const qualityValue = document.getElementById('qualityValue');
|
| if (qualitySlider) {
|
| qualitySlider.value = 0.95;
|
| if (qualityValue) qualityValue.textContent = '95%';
|
| }
|
|
|
|
|
| dom.progressContainer.classList.add('hidden');
|
|
|
|
|
| if (dom.pauseOverlay) {
|
| dom.pauseOverlay.classList.add('hidden');
|
| }
|
|
|
|
|
|
|
|
|
| setControlsDisabled(false);
|
|
|
|
|
| setStatus('Application reset - Ready to start', 'online');
|
|
|
| console.log('[App] Reset complete');
|
| }
|
|
|
|
|
|
|
|
|
|
|
| async function showSecurityStats() {
|
| try {
|
| const result = await window.chahuaVideo.getSecurityStats();
|
| if (result.success) {
|
| const stats = result.stats;
|
| alert(`Security Statistics:\n\n` +
|
| `Total Operations: ${stats.totalOperations}\n` +
|
| `Uptime: ${Math.round(stats.uptime / 1000)}s\n` +
|
| `Rate Limit Entries: ${stats.rateLimitEntries}\n` +
|
| `Cached Hashes: ${stats.cachedHashes}`);
|
| }
|
| } catch (error) {
|
| console.error('Security stats error:', error);
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function showScene(sceneId) {
|
| dom.sceneElements.forEach(scene => {
|
| scene.classList.toggle('active', scene.dataset.scene === sceneId);
|
| });
|
| }
|
|
|
| function setStatus(message, state = 'online') {
|
| dom.statusLog.innerHTML = `<strong>${state === 'recording' ? 'Recording:' : 'Status:'}</strong> ${message}`;
|
| dom.statusPill.textContent = state === 'recording' ? 'Recording' : 'Ready';
|
| dom.statusPill.className = `status-pill ${state}`;
|
| }
|
|
|
| function setControlsDisabled(disabled) {
|
| dom.previewBtn.disabled = disabled;
|
| dom.recordWebMBtn.disabled = disabled;
|
| dom.securityBtn.disabled = disabled;
|
| }
|
|
|
| function wait(ms) {
|
| return new Promise(resolve => setTimeout(resolve, ms));
|
| }
|
|
|
| function formatDuration(seconds) {
|
| const mins = Math.floor(seconds / 60);
|
| const secs = Math.floor(seconds % 60);
|
| return mins > 0 ? `${mins}:${secs.toString().padStart(2, '0')}` : `${secs}s`;
|
| }
|
|
|
| function formatTimecode(seconds) {
|
| const mins = Math.floor(seconds / 60);
|
| const secs = Math.floor(seconds % 60);
|
| return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
|
| }
|
|
|
| function formatBytes(bytes) {
|
| if (bytes === 0) return '0 Bytes';
|
| const k = 1024;
|
| const sizes = ['Bytes', 'KB', 'MB', 'GB'];
|
| const i = Math.floor(Math.log(bytes) / Math.log(k));
|
| return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
|
| }
|
|
|
| function escapeHtml(text) {
|
| const div = document.createElement('div');
|
| div.textContent = text;
|
| return div.innerHTML;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| const slideEditor = new SlideEditor();
|
|
|
| function init() {
|
| console.log('[App] Initializing Markdown Presenter');
|
|
|
|
|
| switchToIntroMode();
|
|
|
|
|
| const savedConfig = loadSavedConfig();
|
| if (savedConfig) {
|
| console.log('[App] Loaded saved configuration from localStorage');
|
| }
|
|
|
| dom.sceneElements = Array.from(document.querySelectorAll('[data-scene]'));
|
|
|
| if (dom.markdownEditor) {
|
| state.markdown = dom.markdownEditor.value;
|
| }
|
|
|
| document.documentElement.style.setProperty('--accent-color', state.themeConfig.accent);
|
|
|
| setupTabs();
|
| setupPresentationSettings();
|
| setupTemplates();
|
| updateTemplateUI();
|
| setupMarkdownControls();
|
| setupConfigInputs();
|
| setupExportControls();
|
| setupPresentationMode();
|
| setupFullscreenControl();
|
| setupStageClickHandler();
|
| setupScreenSensor();
|
| setupConfigManagement();
|
|
|
| if (dom.slideCounter) {
|
| dom.slideCounter.textContent = state.slides.length > 0
|
| ? `${state.currentSlideIndex + 1} / ${state.slides.length}`
|
| : '0 / 0';
|
| }
|
|
|
| if (dom.prevSlideBtn) dom.prevSlideBtn.disabled = true;
|
| if (dom.nextSlideBtn) dom.nextSlideBtn.disabled = true;
|
|
|
|
|
|
|
| if (dom.progressContainer) dom.progressContainer.classList.add('hidden');
|
| if (dom.pauseOverlay) dom.pauseOverlay.classList.add('hidden');
|
|
|
| showScene('intro');
|
| setStatus('Ready - Sync markdown to begin', 'online');
|
| }
|
|
|
| init();
|
|
|
