@social.io/catalog 2.0.0 → 2.1.1

package/dist_ts_web/elements/sio-logo-render.js

@@ -0,0 +1,319 @@
+const facets = [
+    { fill: '#4AA0F5', points: [[250, 75], [150, 133.333], [250, 191.667]] },
+    { fill: '#0A5AC0', points: [[250, 75], [350, 133.333], [250, 191.667]] },
+    { fill: '#DBEBFF', points: [[150, 133.333], [250, 191.667], [150, 250]] },
+    { fill: '#A9CDF7', points: [[250, 191.667], [150, 250], [250, 308.333]] },
+    { fill: '#1E80E6', points: [[250, 191.667], [350, 250], [250, 308.333]] },
+    { fill: '#1466C6', points: [[350, 250], [250, 308.333], [350, 366.667]] },
+    { fill: '#74B4F7', points: [[250, 308.333], [350, 366.667], [250, 425]] },
+    { fill: '#1E80E6', points: [[250, 308.333], [150, 366.667], [250, 425]] },
+];
+const lightFills = [
+    '#4AA0F5', '#0A5AC0', '#8FBEF5', '#77ACEE',
+    '#1E80E6', '#1466C6', '#5FA6F2', '#1E80E6',
+];
+const monoOpacities = [0.78, 0.64, 0.96, 0.86, 0.72, 0.66, 0.82, 0.72];
+const tightBounds = { x: 146, y: 72, width: 208, height: 356 };
+const centerX = 250;
+const centerY = 250;
+export const sioLogoAspect = tightBounds.width / tightBounds.height;
+const centroids = facets.map((facet) => [
+    (facet.points[0][0] + facet.points[1][0] + facet.points[2][0]) / 3,
+    (facet.points[0][1] + facet.points[1][1] + facet.points[2][1]) / 3,
+]);
+const clamp = (value, minimum, maximum) => Math.max(minimum, Math.min(maximum, value));
+const finiteAtLeast = (value, minimum, fallback) => Number.isFinite(value) ? Math.max(minimum, value) : fallback;
+const normalizeOptions = (options) => ({
+    ...options,
+    size: finiteAtLeast(options.size, 1, 40),
+    dpr: clamp(finiteAtLeast(options.dpr, 0.5, 1), 0.5, 4),
+    gap: finiteAtLeast(options.gap, 0, 2),
+    radius: finiteAtLeast(options.radius, 0, 16),
+});
+const inset = (points, gap) => {
+    if (gap <= 0)
+        return points.map(([x, y]) => ({ x, y }));
+    const centroidX = (points[0][0] + points[1][0] + points[2][0]) / 3;
+    const centroidY = (points[0][1] + points[1][1] + points[2][1]) / 3;
+    const lines = [];
+    for (let index = 0; index < points.length; index += 1) {
+        const start = points[index];
+        const end = points[(index + 1) % points.length];
+        let deltaX = end[0] - start[0];
+        let deltaY = end[1] - start[1];
+        const length = Math.hypot(deltaX, deltaY);
+        deltaX /= length;
+        deltaY /= length;
+        let normalX = -deltaY;
+        let normalY = deltaX;
+        const middleX = (start[0] + end[0]) / 2;
+        const middleY = (start[1] + end[1]) / 2;
+        if ((centroidX - middleX) * normalX + (centroidY - middleY) * normalY < 0) {
+            normalX = -normalX;
+            normalY = -normalY;
+        }
+        lines.push({
+            x: start[0] + normalX * gap,
+            y: start[1] + normalY * gap,
+            dx: deltaX,
+            dy: deltaY,
+        });
+    }
+    return lines.map((line, index) => {
+        const previous = lines[(index - 1 + lines.length) % lines.length];
+        const denominator = previous.dx * line.dy - previous.dy * line.dx;
+        const distance = ((line.x - previous.x) * line.dy - (line.y - previous.y) * line.dx) /
+            denominator;
+        return {
+            x: previous.x + previous.dx * distance,
+            y: previous.y + previous.dy * distance,
+        };
+    });
+};
+const createFacetPath = (points, gap, radius) => {
+    const insetPoints = inset(points, gap);
+    const path = new Path2D();
+    if (radius <= 0) {
+        path.moveTo(insetPoints[0].x, insetPoints[0].y);
+        for (let index = 1; index < insetPoints.length; index += 1) {
+            path.lineTo(insetPoints[index].x, insetPoints[index].y);
+        }
+        path.closePath();
+        return path;
+    }
+    for (let index = 0; index < insetPoints.length; index += 1) {
+        const vertex = insetPoints[index];
+        const previous = insetPoints[(index - 1 + insetPoints.length) % insetPoints.length];
+        const next = insetPoints[(index + 1) % insetPoints.length];
+        const previousDistance = Math.hypot(previous.x - vertex.x, previous.y - vertex.y);
+        const nextDistance = Math.hypot(next.x - vertex.x, next.y - vertex.y);
+        const previousRadius = Math.min(radius, previousDistance * 0.5);
+        const nextRadius = Math.min(radius, nextDistance * 0.5);
+        const entry = {
+            x: vertex.x + ((previous.x - vertex.x) / previousDistance) * previousRadius,
+            y: vertex.y + ((previous.y - vertex.y) / previousDistance) * previousRadius,
+        };
+        const exit = {
+            x: vertex.x + ((next.x - vertex.x) / nextDistance) * nextRadius,
+            y: vertex.y + ((next.y - vertex.y) / nextDistance) * nextRadius,
+        };
+        if (index === 0)
+            path.moveTo(entry.x, entry.y);
+        else
+            path.lineTo(entry.x, entry.y);
+        path.quadraticCurveTo(vertex.x, vertex.y, exit.x, exit.y);
+    }
+    path.closePath();
+    return path;
+};
+const easeOutCubic = (progress) => 1 - Math.pow(1 - progress, 3);
+const easeOutBack = (progress) => {
+    const coefficient = 1.70158;
+    return 1 + (coefficient + 1) * Math.pow(progress - 1, 3) + coefficient * Math.pow(progress - 1, 2);
+};
+const easeInCubic = (progress) => progress * progress * progress;
+const easeInBack = (progress) => {
+    const coefficient = 1.70158;
+    return (coefficient + 1) * progress * progress * progress - coefficient * progress * progress;
+};
+const requestFrame = (callback) => {
+    if (typeof globalThis.requestAnimationFrame === 'function') {
+        return globalThis.requestAnimationFrame(callback);
+    }
+    return setTimeout(() => callback(performance.now()), 1000 / 60);
+};
+const cancelFrame = (handle) => {
+    if (typeof globalThis.cancelAnimationFrame === 'function' && typeof handle === 'number') {
+        globalThis.cancelAnimationFrame(handle);
+        return;
+    }
+    clearTimeout(handle);
+};
+export class SioLogoRenderer {
+    context;
+    options;
+    frameHandle = null;
+    phase = null;
+    startedAt = 0;
+    stagger = 70;
+    duration = 560;
+    totalDuration = 0;
+    backingWidth = 0;
+    backingHeight = 0;
+    scale = 1;
+    offsetX = 0;
+    offsetY = 0;
+    paths = [];
+    loadingPaths = [];
+    fills = [];
+    opacities = [];
+    constructor(context, options) {
+        this.context = context;
+        this.options = normalizeOptions(options);
+        this.rebuild();
+    }
+    setOptions(options) {
+        this.options = normalizeOptions(options);
+        this.rebuild();
+        if (!this.phase)
+            this.drawStatic();
+    }
+    drawStatic() {
+        this.clearCanvas();
+        for (let index = 0; index < facets.length; index += 1) {
+            this.paint(index, 0, 0, 0, 1, this.opacities[index], this.paths[index]);
+        }
+        this.context.globalAlpha = 1;
+    }
+    clear() {
+        this.stop();
+        this.clearCanvas();
+    }
+    start(phase) {
+        this.stop();
+        this.phase = phase;
+        this.startedAt = performance.now();
+        this.stagger = phase === 'wave' ? 55 : 70;
+        this.duration = phase === 'wave' ? 420 : 560;
+        this.totalDuration = this.stagger * (facets.length - 1) + this.duration;
+        const drawFrame = (time) => {
+            if (!this.phase)
+                return;
+            const elapsed = time - this.startedAt;
+            this.drawAnimationFrame(elapsed);
+            if (this.phase !== 'loading' && elapsed >= this.totalDuration) {
+                this.settle();
+                return;
+            }
+            this.frameHandle = requestFrame(drawFrame);
+        };
+        this.frameHandle = requestFrame(drawFrame);
+    }
+    stop() {
+        if (this.frameHandle !== null) {
+            cancelFrame(this.frameHandle);
+            this.frameHandle = null;
+        }
+        this.phase = null;
+    }
+    rebuild() {
+        const { size, dpr, square, light, mono, gap, radius } = this.options;
+        this.backingWidth = Math.round((square ? size : size * sioLogoAspect) * dpr);
+        this.backingHeight = Math.round(size * dpr);
+        this.context.canvas.width = this.backingWidth;
+        this.context.canvas.height = this.backingHeight;
+        if (square) {
+            this.scale = this.backingWidth / 500;
+            this.offsetX = 0;
+            this.offsetY = 0;
+        }
+        else {
+            this.scale = this.backingHeight / tightBounds.height;
+            this.offsetX =
+                -tightBounds.x * this.scale +
+                    (this.backingWidth - tightBounds.width * this.scale) / 2;
+            this.offsetY = -tightBounds.y * this.scale;
+        }
+        this.paths = facets.map((facet) => createFacetPath(facet.points, gap, radius));
+        this.loadingPaths = facets.map((facet) => createFacetPath(facet.points, gap + 3, 90));
+        this.fills = facets.map((facet, index) => mono || (light ? lightFills[index] : facet.fill));
+        this.opacities = facets.map((_, index) => (mono ? monoOpacities[index] : 1));
+    }
+    clearCanvas() {
+        this.context.setTransform(1, 0, 0, 1, 0, 0);
+        this.context.clearRect(0, 0, this.backingWidth, this.backingHeight);
+        const { background } = this.options;
+        if (background && background !== 'transparent' && background !== 'none') {
+            this.context.fillStyle = background;
+            this.context.fillRect(0, 0, this.backingWidth, this.backingHeight);
+        }
+    }
+    paint(index, translateX, translateY, rotation, scale, opacity, path) {
+        const [centroidX, centroidY] = centroids[index];
+        this.context.setTransform(this.scale, 0, 0, this.scale, this.offsetX, this.offsetY);
+        this.context.translate(translateX, translateY);
+        this.context.translate(centroidX, centroidY);
+        this.context.rotate((rotation * Math.PI) / 180);
+        this.context.scale(scale, scale);
+        this.context.translate(-centroidX, -centroidY);
+        this.context.globalAlpha = opacity;
+        this.context.fillStyle = this.fills[index];
+        this.context.fill(path);
+    }
+    drawAnimationFrame(elapsed) {
+        this.clearCanvas();
+        const activePhase = this.phase;
+        for (let index = 0; index < facets.length; index += 1) {
+            const [centroidX, centroidY] = centroids[index];
+            let translateX = 0;
+            let translateY = 0;
+            let rotation = 0;
+            let scale = 1;
+            let opacity = this.opacities[index];
+            let path = this.paths[index];
+            if (activePhase === 'in') {
+                const progress = clamp((elapsed - index * this.stagger) / this.duration, 0, 1);
+                const eased = easeOutCubic(progress);
+                translateX = (centerX - centroidX) * (1 - eased);
+                translateY = (centerY - centroidY) * (1 - eased);
+                rotation = (1 - eased) * -16;
+                scale = easeOutBack(progress);
+                opacity = clamp(progress * 1.6, 0, 1) * this.opacities[index];
+            }
+            else if (activePhase === 'out') {
+                const reverseIndex = facets.length - 1 - index;
+                const progress = clamp((elapsed - reverseIndex * this.stagger) / this.duration, 0, 1);
+                const eased = easeInCubic(progress);
+                translateX = (centerX - centroidX) * eased;
+                translateY = (centerY - centroidY) * eased;
+                rotation = progress * 16;
+                scale = Math.max(0, 1 - easeInBack(progress));
+                opacity = clamp(1 - progress * 1.3, 0, 1) * this.opacities[index];
+            }
+            else if (activePhase === 'wave') {
+                const progress = clamp((elapsed - index * this.stagger) / this.duration, 0, 1);
+                const pulse = Math.sin(progress * Math.PI);
+                const radialX = centroidX - centerX;
+                const radialY = centroidY - centerY;
+                const radialLength = Math.hypot(radialX, radialY) || 1;
+                translateX = (radialX / radialLength) * 16 * pulse;
+                translateY = (radialY / radialLength) * 16 * pulse;
+                scale = 1 - 0.08 * pulse;
+            }
+            else if (activePhase === 'loading') {
+                const growth = clamp(elapsed / 650, 0, 1);
+                const easedGrowth = growth < 0.5
+                    ? 2 * growth * growth
+                    : 1 - Math.pow(-2 * growth + 2, 2) / 2;
+                const looping = elapsed >= 650;
+                const spin = (elapsed / 1500) * 2 * Math.PI;
+                const angle = -Math.PI / 2 + index * Math.PI / 4 + spin;
+                const destinationX = centerX + 120 * Math.cos(angle);
+                const destinationY = centerY + 120 * Math.sin(angle);
+                const brightness = 1 - index / facets.length;
+                translateX = (destinationX - centroidX) * easedGrowth;
+                translateY = (destinationY - centroidY) * easedGrowth;
+                scale =
+                    (1 + (0.62 - 1) * easedGrowth) *
+                        (looping ? 0.72 + 0.28 * brightness : 1);
+                opacity = (looping ? 0.28 + 0.72 * brightness : 1) * this.opacities[index];
+                path = looping
+                    ? this.loadingPaths[index]
+                    : createFacetPath(facets[index].points, this.options.gap + 3 * easedGrowth, this.options.radius + (90 - this.options.radius) * easedGrowth);
+            }
+            this.paint(index, translateX, translateY, rotation, scale, opacity, path);
+        }
+        this.context.globalAlpha = 1;
+    }
+    settle() {
+        const finishedPhase = this.phase;
+        this.frameHandle = null;
+        this.phase = null;
+        if (finishedPhase === 'out')
+            this.clearCanvas();
+        else
+            this.drawStatic();
+        this.context.globalAlpha = 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sio-logo-render.js","sourceRoot":"","sources":["../../ts_web/elements/sio-logo-render.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/elements/sio-logo-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist_ts_web/elements/sio-logo-worker.js

@@ -0,0 +1,38 @@
+import { SioLogoRenderer, } from './sio-logo-render.js';
+const workerScope = globalThis;
+let renderer = null;
+workerScope.onmessage = (event) => {
+    const message = event.data;
+    if (message.type === 'init') {
+        const context = message.canvas.getContext('2d');
+        if (!context)
+            throw new Error('Unable to create the sio-logo worker canvas context.');
+        renderer = new SioLogoRenderer(context, message.options);
+        if (message.phase)
+            renderer.start(message.phase);
+        else
+            renderer.drawStatic();
+        workerScope.postMessage({ type: 'initialized' });
+        return;
+    }
+    if (!renderer)
+        return;
+    if (message.type === 'options') {
+        renderer.setOptions(message.options);
+        return;
+    }
+    if (message.phase === 'stop') {
+        renderer.stop();
+        renderer.drawStatic();
+    }
+    else if (message.phase === 'clear') {
+        renderer.clear();
+    }
+    else {
+        renderer.start(message.phase);
+    }
+};
+// The canvas is transferred only after the module and its renderer dependency
+// have loaded, leaving the HTMLCanvasElement intact for pre-transfer fallback.
+workerScope.postMessage({ type: 'ready' });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lvLWxvZ28td29ya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViL2VsZW1lbnRzL3Npby1sb2dvLXdvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxHQUdoQixNQUFNLHNCQUFzQixDQUFDO0FBNkI5QixNQUFNLFdBQVcsR0FBRyxVQUE0QyxDQUFDO0FBQ2pFLElBQUksUUFBUSxHQUEyQixJQUFJLENBQUM7QUFFNUMsV0FBVyxDQUFDLFNBQVMsR0FBRyxDQUFDLEtBQUssRUFBUSxFQUFFO0lBQ3RDLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUM7SUFDM0IsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQzVCLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2hELElBQUksQ0FBQyxPQUFPO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxzREFBc0QsQ0FBQyxDQUFDO1FBQ3RGLFFBQVEsR0FBRyxJQUFJLGVBQWUsQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3pELElBQUksT0FBTyxDQUFDLEtBQUs7WUFBRSxRQUFRLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQzs7WUFDNUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQzNCLFdBQVcsQ0FBQyxXQUFXLENBQUMsRUFBRSxJQUFJLEVBQUUsYUFBYSxFQUFFLENBQUMsQ0FBQztRQUNqRCxPQUFPO0lBQ1QsQ0FBQztJQUVELElBQUksQ0FBQyxRQUFRO1FBQUUsT0FBTztJQUN0QixJQUFJLE9BQU8sQ0FBQyxJQUFJLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDL0IsUUFBUSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDckMsT0FBTztJQUNULENBQUM7SUFFRCxJQUFJLE9BQU8sQ0FBQyxLQUFLLEtBQUssTUFBTSxFQUFFLENBQUM7UUFDN0IsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2hCLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUN4QixDQUFDO1NBQU0sSUFBSSxPQUFPLENBQUMsS0FBSyxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQ3JDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNuQixDQUFDO1NBQU0sQ0FBQztRQUNOLFFBQVEsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hDLENBQUM7QUFDSCxDQUFDLENBQUM7QUFFRiw4RUFBOEU7QUFDOUUsK0VBQStFO0FBQy9FLFdBQVcsQ0FBQyxXQUFXLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQyJ9

package/dist_ts_web/elements/sio-logo.d.ts

@@ -0,0 +1,85 @@
+import { DeesElement, type TemplateResult } from '@design.estate/dees-element';
+export type TSioLogoTheme = 'auto' | 'light' | 'dark';
+declare global {
+    interface HTMLElementTagNameMap {
+        'sio-logo': SioLogo;
+    }
+}
+/**
+ * The social.io faceted S brand mark from the v8 design prototype.
+ *
+ * Geometry and animation run on an OffscreenCanvas in a module worker when the
+ * browser and consumer bundle support it. The same renderer is used on the
+ * main thread as a safe fallback.
+ */
+export declare class SioLogo extends DeesElement {
+    static demo: () => TemplateResult<1>;
+    /** rendered height in CSS pixels; tight-crop width follows the brand aspect */
+    accessor size: number;
+    accessor background: string;
+    /** inward inset per facet, in 500px design-grid units */
+    accessor gap: number;
+    /** facet corner radius, in 500px design-grid units */
+    accessor radius: number;
+    /** render on a square tile instead of the tight S crop */
+    accessor square: boolean;
+    /** collapse the palette to one color while retaining facet depth */
+    accessor mono: string;
+    /** backdrop palette; auto follows the nearest opaque surface */
+    accessor theme: TSioLogoTheme;
+    accessor loading: boolean;
+    accessor noEntrance: boolean;
+    accessor noHover: boolean;
+    private accessor canvasGeneration;
+    static styles: import("@design.estate/dees-element").CSSResult[];
+    private backendState;
+    private worker;
+    private renderer;
+    private canvasTransferred;
+    private forceMainThread;
+    private initializationTimeout;
+    private initializationGeneration;
+    private lifecycleGeneration;
+    private initialUpdateHandled;
+    private queuedOptions;
+    private queuedPhase;
+    private themeObserver;
+    private reducedMotionMedia;
+    private lastDevicePixelRatio;
+    private lastLight;
+    private readonly handlePointerEnter;
+    private readonly handleAmbientChange;
+    private readonly handleReducedMotionChange;
+    private readonly handleResize;
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): Promise<void>;
+    private cleanupOwnedResources;
+    render(): TemplateResult;
+    firstUpdated(changedProperties: Map<PropertyKey, unknown>): void;
+    updated(changedProperties: Map<PropertyKey, unknown>): void;
+    protected themeChanged(): void;
+    play(): void;
+    wave(): void;
+    dismiss(): void;
+    private initializeCanvas;
+    private handleWorkerReady;
+    private handleWorkerInitialized;
+    private handleWorkerFailure;
+    private initializeMainThread;
+    private armInitializationTimeout;
+    private clearInitializationTimeout;
+    private isCurrentWorker;
+    private destroyBackend;
+    private get normalizedSize();
+    private getRendererOptions;
+    private getInitialPhase;
+    private syncRendererOptions;
+    private sendPhase;
+    private prefersReducedMotion;
+    private isLightBackdrop;
+    private observeAmbientTheme;
+    private stopAmbientThemeObservation;
+    private observeReducedMotion;
+    private stopReducedMotionObservation;
+    private ensureAccessibleHost;
+}