@design.estate/wcctools 5.1.0 → 6.0.0

package/dist_ts_shell/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The wcctools shell bundle: the catalog UI that `wcctools dev` serves on `/wcctools/`.
+ */
+export { WccShell } from './elements/wcc-shell.js';

package/dist_ts_shell/index.js

@@ -0,0 +1,5 @@
+/**
+ * The wcctools shell bundle: the catalog UI that `wcctools dev` serves on `/wcctools/`.
+ */
+export { WccShell } from './elements/wcc-shell.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19zaGVsbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dist_ts_shell/plugins.d.ts

@@ -0,0 +1,4 @@
+import * as deesDomtools from '@design.estate/dees-domtools';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import * as shared from '../dist_ts_shared/index.js';
+export { deesDomtools, interfaces, shared, };

package/dist_ts_shell/plugins.js

@@ -0,0 +1,5 @@
+import * as deesDomtools from '@design.estate/dees-domtools';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import * as shared from '../dist_ts_shared/index.js';
+export { deesDomtools, interfaces, shared, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3NoZWxsL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLFlBQVksTUFBTSw4QkFBOEIsQ0FBQztBQUU3RCxPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBQ3hELE9BQU8sS0FBSyxNQUFNLE1BQU0sdUJBQXVCLENBQUM7QUFFaEQsT0FBTyxFQUNMLFlBQVksRUFDWixVQUFVLEVBQ1YsTUFBTSxHQUNQLENBQUMifQ==

package/dist_ts_shell/previewconnection.d.ts

@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+export interface IWccPreviewConnectionHandlers {
+    /** A preview document installed its bridge; called again after every reload of the frame. */
+    onReady: (bridgeArg: plugins.interfaces.IWccPreviewBridge) => void;
+    /** The connected preview document is going away (reload or navigation). */
+    onDisconnect: () => void;
+    onEscape: () => void;
+    onScroll: (scrollYArg: number) => void;
+}
+/**
+ * The shell's connection to the preview document in its preview iframe. Each preview document posts
+ * a ready message once its bridge is installed; the connection then binds that document's
+ * bridge and listeners, and releases them when the document is hidden, so nothing of a
+ * replaced document stays referenced.
+ */
+export declare class WccPreviewConnection {
+    private readonly getIframe;
+    private readonly handlers;
+    private bridgeValue;
+    private documentDisposers;
+    private started;
+    constructor(getIframe: () => HTMLIFrameElement | null, handlers: IWccPreviewConnectionHandlers);
+    get bridge(): plugins.interfaces.IWccPreviewBridge | null;
+    start(): void;
+    dispose(): void;
+    scrollPreviewTo(scrollYArg: number): void;
+    private handleMessage;
+    private bindDocument;
+    private releaseDocument;
+}

package/dist_ts_shell/previewconnection.js

@@ -0,0 +1,86 @@
+import * as plugins from './plugins.js';
+/**
+ * The shell's connection to the preview document in its preview iframe. Each preview document posts
+ * a ready message once its bridge is installed; the connection then binds that document's
+ * bridge and listeners, and releases them when the document is hidden, so nothing of a
+ * replaced document stays referenced.
+ */
+export class WccPreviewConnection {
+    getIframe;
+    handlers;
+    bridgeValue = null;
+    documentDisposers = [];
+    started = false;
+    constructor(getIframe, handlers) {
+        this.getIframe = getIframe;
+        this.handlers = handlers;
+    }
+    get bridge() {
+        return this.bridgeValue;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        window.addEventListener('message', this.handleMessage);
+    }
+    dispose() {
+        window.removeEventListener('message', this.handleMessage);
+        this.started = false;
+        this.releaseDocument();
+    }
+    scrollPreviewTo(scrollYArg) {
+        if (this.bridgeValue) {
+            this.getIframe()?.contentWindow?.scrollTo(0, scrollYArg);
+        }
+    }
+    handleMessage = (eventArg) => {
+        const previewWindow = this.getIframe()?.contentWindow;
+        if (!previewWindow
+            || eventArg.source !== previewWindow
+            || eventArg.origin !== window.location.origin
+            || !plugins.shared.isPreviewReadyMessage(eventArg.data)) {
+            return;
+        }
+        // A document that reloaded again since it posted installs its own bridge and posts again
+        const bridge = previewWindow.wccPreview;
+        if (!bridge) {
+            return;
+        }
+        this.releaseDocument();
+        this.bindDocument(previewWindow, bridge);
+        this.handlers.onReady(bridge);
+    };
+    bindDocument(previewWindowArg, bridgeArg) {
+        this.bridgeValue = bridgeArg;
+        const onKeydown = (eventArg) => {
+            if (eventArg.key === 'Escape') {
+                this.handlers.onEscape();
+            }
+        };
+        const onScroll = () => {
+            this.handlers.onScroll(previewWindowArg.scrollY);
+        };
+        const onPagehide = () => {
+            this.releaseDocument();
+            this.handlers.onDisconnect();
+        };
+        previewWindowArg.addEventListener('keydown', onKeydown);
+        previewWindowArg.addEventListener('scroll', onScroll, { passive: true });
+        previewWindowArg.addEventListener('pagehide', onPagehide);
+        this.documentDisposers = [
+            () => previewWindowArg.removeEventListener('keydown', onKeydown),
+            () => previewWindowArg.removeEventListener('scroll', onScroll),
+            () => previewWindowArg.removeEventListener('pagehide', onPagehide),
+        ];
+    }
+    releaseDocument() {
+        for (const dispose of this.documentDisposers) {
+            dispose();
+        }
+        this.documentDisposers = [];
+        this.bridgeValue = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_shell/services/recorder.service.js

@@ -0,0 +1,353 @@
+/**
+ * RecorderService - Handles all MediaRecorder, audio monitoring, and video export logic.
+ * Recording always uses MediaRecorder → WebM (the reliable browser path).
+ * MP4 output is produced by converting WebM → MP4 via mediabunny at export time.
+ */
+export class RecorderService {
+    // Recording state
+    mediaRecorder = null;
+    recordedChunks = [];
+    durationInterval = null;
+    _duration = 0;
+    _recordedBlob = null;
+    _isRecording = false;
+    _outputFormat = 'webm';
+    // Audio monitoring state
+    audioContext = null;
+    audioAnalyser = null;
+    audioMonitoringInterval = null;
+    monitoringStream = null;
+    // Current recording stream
+    currentStream = null;
+    // Event callbacks
+    events = {};
+    constructor(events) {
+        if (events) {
+            this.events = events;
+        }
+    }
+    // Public getters
+    get isRecording() {
+        return this._isRecording;
+    }
+    get duration() {
+        return this._duration;
+    }
+    get recordedBlob() {
+        return this._recordedBlob;
+    }
+    get outputFormat() {
+        return this._outputFormat;
+    }
+    // Update event callbacks
+    setEvents(events) {
+        this.events = { ...this.events, ...events };
+    }
+    // ==================== Microphone Management ====================
+    async loadMicrophones(requestPermission = false) {
+        try {
+            if (requestPermission) {
+                // Request permission by getting a temporary stream
+                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+                stream.getTracks().forEach(track => track.stop());
+            }
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter(d => d.kind === 'audioinput');
+        }
+        catch (error) {
+            console.error('Error loading microphones:', error);
+            return [];
+        }
+    }
+    async startAudioMonitoring(deviceId) {
+        this.stopAudioMonitoring();
+        if (!deviceId)
+            return;
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: { deviceId: { exact: deviceId } }
+            });
+            this.monitoringStream = stream;
+            this.audioContext = new AudioContext();
+            const source = this.audioContext.createMediaStreamSource(stream);
+            this.audioAnalyser = this.audioContext.createAnalyser();
+            this.audioAnalyser.fftSize = 256;
+            source.connect(this.audioAnalyser);
+            const dataArray = new Uint8Array(this.audioAnalyser.frequencyBinCount);
+            this.audioMonitoringInterval = window.setInterval(() => {
+                if (this.audioAnalyser) {
+                    this.audioAnalyser.getByteFrequencyData(dataArray);
+                    const average = dataArray.reduce((a, b) => a + b) / dataArray.length;
+                    const level = Math.min(100, (average / 128) * 100);
+                    this.events.onAudioLevelUpdate?.(level);
+                }
+            }, 50);
+        }
+        catch (error) {
+            console.error('Error starting audio monitoring:', error);
+            this.events.onAudioLevelUpdate?.(0);
+        }
+    }
+    stopAudioMonitoring() {
+        if (this.audioMonitoringInterval) {
+            clearInterval(this.audioMonitoringInterval);
+            this.audioMonitoringInterval = null;
+        }
+        if (this.audioContext) {
+            this.audioContext.close();
+            this.audioContext = null;
+        }
+        if (this.monitoringStream) {
+            this.monitoringStream.getTracks().forEach(track => track.stop());
+            this.monitoringStream = null;
+        }
+        this.audioAnalyser = null;
+    }
+    // ==================== Recording Control ====================
+    async startRecording(options) {
+        try {
+            this._outputFormat = options.outputFormat || 'webm';
+            // Stop audio monitoring before recording
+            this.stopAudioMonitoring();
+            // Get video stream based on mode
+            const displayMediaOptions = {
+                video: {
+                    displaySurface: options.mode === 'viewport' ? 'browser' : 'monitor',
+                    frameRate: { ideal: 60 },
+                },
+                audio: false
+            };
+            // Add preferCurrentTab hint for viewport mode
+            if (options.mode === 'viewport') {
+                displayMediaOptions.preferCurrentTab = true;
+            }
+            const videoStream = await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);
+            // If viewport mode, try to crop to viewport element using Element Capture API
+            if (options.mode === 'viewport' && options.viewportElement) {
+                try {
+                    if ('CropTarget' in window) {
+                        const cropTarget = await window.CropTarget.fromElement(options.viewportElement);
+                        const [videoTrack] = videoStream.getVideoTracks();
+                        await videoTrack.cropTo(cropTarget);
+                    }
+                }
+                catch (e) {
+                    console.warn('Element Capture not supported, recording full tab:', e);
+                }
+            }
+            // Combine video with audio if enabled
+            let combinedStream = videoStream;
+            if (options.audioDeviceId) {
+                try {
+                    const audioStream = await navigator.mediaDevices.getUserMedia({
+                        audio: { deviceId: { exact: options.audioDeviceId } }
+                    });
+                    combinedStream = new MediaStream([
+                        ...videoStream.getVideoTracks(),
+                        ...audioStream.getAudioTracks()
+                    ]);
+                }
+                catch (audioError) {
+                    console.warn('Could not add audio:', audioError);
+                }
+            }
+            // Store stream for cleanup
+            this.currentStream = combinedStream;
+            // Handle stream ending (user clicks "Stop sharing")
+            videoStream.getVideoTracks()[0].onended = () => {
+                if (this._isRecording) {
+                    this.stopRecording();
+                    this.events.onStreamEnded?.();
+                }
+            };
+            // Always record as WebM — conversion to MP4 happens at export time
+            const mimeType = MediaRecorder.isTypeSupported('video/webm;codecs=vp9')
+                ? 'video/webm;codecs=vp9'
+                : 'video/webm';
+            this.mediaRecorder = new MediaRecorder(combinedStream, {
+                mimeType,
+                videoBitsPerSecond: 8_000_000, // 8 Mbps for smooth, high-quality capture
+            });
+            this.recordedChunks = [];
+            this.mediaRecorder.ondataavailable = (e) => {
+                if (e.data.size > 0) {
+                    this.recordedChunks.push(e.data);
+                }
+            };
+            this.mediaRecorder.onstop = () => this.handleRecordingComplete();
+            this.mediaRecorder.start(1000); // Capture in 1-second chunks
+            // Start duration timer
+            this._duration = 0;
+            this.durationInterval = window.setInterval(() => {
+                this._duration++;
+                this.events.onDurationUpdate?.(this._duration);
+            }, 1000);
+            this._isRecording = true;
+        }
+        catch (error) {
+            console.error('Error starting recording:', error);
+            this._isRecording = false;
+            this.events.onError?.(error);
+            throw error;
+        }
+    }
+    stopRecording() {
+        if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+            this.mediaRecorder.stop();
+        }
+        if (this.durationInterval) {
+            clearInterval(this.durationInterval);
+            this.durationInterval = null;
+        }
+    }
+    async handleRecordingComplete() {
+        const blob = new Blob(this.recordedChunks, { type: 'video/webm' });
+        this._recordedBlob = blob;
+        // Stop all tracks
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach(track => track.stop());
+            this.currentStream = null;
+        }
+        this._isRecording = false;
+        this.events.onRecordingComplete?.(this._recordedBlob);
+    }
+    // ==================== Conversion & Export ====================
+    /**
+     * Converts a WebM blob to MP4 using mediabunny's Conversion API.
+     * Uses WebCodecs for hardware-accelerated H.264 encoding.
+     */
+    async convertToMp4(webmBlob) {
+        const { Input, Output, Conversion, BlobSource, BufferTarget, Mp4OutputFormat, WEBM, QUALITY_HIGH, } = await import('mediabunny');
+        const input = new Input({
+            source: new BlobSource(webmBlob),
+            formats: [WEBM],
+        });
+        const target = new BufferTarget();
+        const output = new Output({
+            format: new Mp4OutputFormat({ fastStart: 'in-memory' }),
+            target,
+        });
+        const conversion = await Conversion.init({
+            input,
+            output,
+            // Force transcoding from VP9 → H.264 and Opus → AAC
+            video: {
+                codec: 'avc',
+                bitrate: QUALITY_HIGH,
+                fit: 'contain',
+            },
+            audio: {
+                codec: 'aac',
+                bitrate: QUALITY_HIGH,
+            },
+        });
+        await conversion.execute();
+        const buffer = target.buffer;
+        if (!buffer || buffer.byteLength === 0) {
+            throw new Error('MP4 conversion produced empty output');
+        }
+        return new Blob([buffer], { type: 'video/mp4' });
+    }
+    async exportTrimmedVideo(videoElement, trimStart, trimEnd) {
+        return new Promise((resolve, reject) => {
+            // Create a canvas for capturing frames
+            const canvas = document.createElement('canvas');
+            canvas.width = videoElement.videoWidth || 1280;
+            canvas.height = videoElement.videoHeight || 720;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error('Could not get canvas context'));
+                return;
+            }
+            // Create canvas stream for video
+            const canvasStream = canvas.captureStream(30);
+            // Try to capture audio from video element
+            let combinedStream;
+            try {
+                // Create audio context to capture video's audio
+                const audioCtx = new AudioContext();
+                const source = audioCtx.createMediaElementSource(videoElement);
+                const destination = audioCtx.createMediaStreamDestination();
+                source.connect(destination);
+                source.connect(audioCtx.destination); // Also play through speakers
+                // Combine video (from canvas) and audio (from video element)
+                combinedStream = new MediaStream([
+                    ...canvasStream.getVideoTracks(),
+                    ...destination.stream.getAudioTracks()
+                ]);
+                // Store audioCtx for cleanup
+                const cleanup = () => {
+                    audioCtx.close();
+                };
+                this.recordTrimmedStream(videoElement, canvas, ctx, combinedStream, trimStart, trimEnd, cleanup, resolve, reject);
+            }
+            catch (audioError) {
+                console.warn('Could not capture audio, recording video only:', audioError);
+                combinedStream = canvasStream;
+                this.recordTrimmedStream(videoElement, canvas, ctx, combinedStream, trimStart, trimEnd, () => { }, resolve, reject);
+            }
+        });
+    }
+    recordTrimmedStream(video, canvas, ctx, stream, trimStart, trimEnd, cleanup, resolve, reject) {
+        const mimeType = MediaRecorder.isTypeSupported('video/webm;codecs=vp9')
+            ? 'video/webm;codecs=vp9'
+            : 'video/webm';
+        const recorder = new MediaRecorder(stream, { mimeType });
+        const chunks = [];
+        recorder.ondataavailable = (e) => {
+            if (e.data.size > 0) {
+                chunks.push(e.data);
+            }
+        };
+        recorder.onstop = () => {
+            cleanup();
+            resolve(new Blob(chunks, { type: 'video/webm' }));
+        };
+        recorder.onerror = (e) => {
+            cleanup();
+            reject(new Error('Recording error: ' + e));
+        };
+        // Seek to trim start
+        video.currentTime = trimStart;
+        video.onseeked = () => {
+            // Start recording
+            recorder.start(100);
+            // Start playing
+            video.play();
+            // Draw frames to canvas
+            const drawFrame = () => {
+                if (video.currentTime >= trimEnd || video.paused || video.ended) {
+                    video.pause();
+                    video.onseeked = null;
+                    // Give a small delay before stopping to ensure last frame is captured
+                    setTimeout(() => {
+                        if (recorder.state === 'recording') {
+                            recorder.stop();
+                        }
+                    }, 100);
+                    return;
+                }
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                requestAnimationFrame(drawFrame);
+            };
+            drawFrame();
+        };
+    }
+    // ==================== Cleanup ====================
+    reset() {
+        this._recordedBlob = null;
+        this.recordedChunks = [];
+        this._duration = 0;
+        this._isRecording = false;
+    }
+    dispose() {
+        this.stopRecording();
+        this.stopAudioMonitoring();
+        this.reset();
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach(track => track.stop());
+            this.currentStream = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.service.js","sourceRoot":"","sources":["../../../ts_shell/services/recorder.service.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@design.estate/wcctools',
-    version: '5.1.0',
+    version: '6.0.0',
     description: 'A set of web component tools for creating element catalogues, enabling the structured development and documentation of custom elements and pages.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUseUJBQXlCO0lBQy9CLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSxtSkFBbUo7Q0FDakssQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUseUJBQXlCO0lBQy9CLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSxtSkFBbUo7Q0FDakssQ0FBQSJ9

package/dist_ts_web/catalog.d.ts

@@ -0,0 +1,45 @@
+import * as plugins from './wcctools.plugins.js';
+import { type ICatalogElementConstructor, type TTemplateFactory } from './elements/wcctools.helpers.js';
+import type { IWccConfig, IWccSection } from './wcctools.interfaces.js';
+type TSectionEntry = [string, any];
+/**
+ * The navigable entries of a section, after classification and the section's own filter and sort.
+ * Elements sections keep only custom element classes with a usable static `demo`;
+ * pages sections keep only template factories.
+ */
+export declare const getSectionItems: (section: IWccSection) => TSectionEntry[];
+/**
+ * Registered custom elements of an elements section that have no usable demo.
+ * They are listed (not navigable) in the sidebar's "Without demo" group.
+ */
+export declare const getSectionItemsWithoutDemo: (section: IWccSection) => TSectionEntry[];
+/** What a selection resolves to: something to render, or the reason there is nothing. */
+export type TWccCatalogTarget = {
+    kind: 'element';
+    factory: TTemplateFactory;
+    elementClass: ICatalogElementConstructor;
+} | {
+    kind: 'page';
+    factory: TTemplateFactory;
+} | {
+    kind: 'empty';
+    reason: plugins.interfaces.TWccEmptyReason;
+    emptyState: plugins.interfaces.IWccEmptyState;
+};
+/**
+ * The catalog of one `setupWccTools` call: classifies its sections, describes them as a
+ * data-only manifest and resolves selections to template factories.
+ */
+export declare class WccCatalog {
+    private readonly sections;
+    constructor(configArg: IWccConfig);
+    getManifest(): plugins.interfaces.IWccCatalogManifest;
+    resolve(selectionArg: plugins.interfaces.IWccSelection | null): TWccCatalogTarget;
+    /**
+     * Resolve a section/item pair to a listed entry, or to the reason it cannot be previewed.
+     * The section names `element` and `page` of links from before sections existed search every section.
+     */
+    private resolveEntry;
+    private getUnavailableEmptyState;
+}
+export {};