@genesislcap/ai-assistant 14.458.1-GENC-0.3 → 14.458.2

package/dist/esm/utils/animation-exclusivity.js

@@ -1,33 +0,0 @@
-import { LOADING_STYLE_ANIMATIONS } from '../main/main.types';
-/**
- * Enforces that at most one loading-indicator style (dots vs. waves) is enabled
- * at a time. The two are alternative presentations of the same "assistant is
- * working" state, so selecting one must deselect the other.
- *
- * The settings control is a multiselect (checkboxes), which permits selecting
- * both; this resolver makes the loading-style group behave like a radio group
- * by dropping the previously-selected style whenever a new one is added.
- *
- * @param next - The freshly-selected animation list (e.g. emitted by the
- *   multiselect, or read from consumer config).
- * @param previous - The animation list in effect before this change. Used to
- *   work out which loading style was just added so the other can be dropped.
- *   Pass `[]` when resolving an initial/config value with no prior state.
- * @returns `next` with at most one loading style retained. When both are
- *   present and neither is newly added (e.g. a misconfigured `enabled` list),
- *   the first entry of `LOADING_STYLE_ANIMATIONS` (dots) wins.
- *
- * @internal
- */
-export function resolveExclusiveLoadingStyle(next, previous = []) {
-    var _a;
-    const selectedStyles = LOADING_STYLE_ANIMATIONS.filter((style) => next.includes(style));
-    if (selectedStyles.length <= 1) {
-        return next;
-    }
-    // Both styles selected — keep whichever was just added (absent from
-    // `previous`); fall back to the first declared style on ambiguity.
-    const justAdded = (_a = selectedStyles.find((style) => !previous.includes(style))) !== null && _a !== void 0 ? _a : selectedStyles[0];
-    return next.filter((animation) => animation === justAdded ||
-        !LOADING_STYLE_ANIMATIONS.includes(animation));
-}

package/dist/esm/utils/animation-exclusivity.test.js

@@ -1,41 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
-const suite = createLogicSuite('resolveExclusiveLoadingStyle');
-suite('leaves a selection with only the dots loading style untouched', () => {
-    const next = ['loading', 'halo'];
-    assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['loading', 'halo']);
-});
-suite('leaves a selection with only the waves loading style untouched', () => {
-    const next = ['waves', 'halo'];
-    assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['waves', 'halo']);
-});
-suite('leaves a selection with no loading style untouched', () => {
-    assert.equal(resolveExclusiveLoadingStyle(['halo'], []), ['halo']);
-});
-suite('drops dots when waves was just added on top of dots', () => {
-    // Previously dots was on; user ticks waves → waves wins, dots removed.
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['loading', 'halo']);
-    assert.equal(result, ['waves', 'halo']);
-});
-suite('drops waves when dots was just added on top of waves', () => {
-    // Previously waves was on; user ticks dots → dots wins, waves removed.
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['waves', 'halo']);
-    assert.equal(result, ['loading', 'halo']);
-});
-suite('preserves the order of the surviving selection', () => {
-    const result = resolveExclusiveLoadingStyle(['halo', 'loading', 'waves'], ['halo', 'loading']);
-    // waves was just added → loading dropped; halo and waves keep their order.
-    assert.equal(result, ['halo', 'waves']);
-});
-suite('falls back to dots when both are present with no prior state (e.g. bad config)', () => {
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], []);
-    assert.equal(result, ['loading', 'halo']);
-});
-suite('falls back to dots when both were already present (neither newly added)', () => {
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves'], ['loading', 'waves', 'halo']);
-    assert.equal(result, ['loading']);
-});
-suite('handles an empty selection', () => {
-    assert.equal(resolveExclusiveLoadingStyle([], ['loading']), []);
-});
-suite.run();

package/src/components/waves-indicator.ts

@@ -1,212 +0,0 @@
-import { avoidTreeShaking } from '@genesislcap/foundation-utils';
-import { attr, css, customElement, GenesisElement, html } from '@genesislcap/web-core';
-import {
-  AI_COLOUR_AMBER,
-  AI_COLOUR_CYAN,
-  AI_COLOUR_PINK,
-  AI_COLOUR_VIOLET,
-} from '../styles/ai-colours';
-import { AiHaloOverlay } from './halo-overlay';
-
-const WAVES_DEFAULT_SIZE = 56;
-/** CSS-ready form of `WAVES_DEFAULT_SIZE` (the `css` tag rejects raw numbers). */
-const WAVES_DEFAULT_SIZE_CSS = `${WAVES_DEFAULT_SIZE}px`;
-
-/** SVG coordinate space the waves are drawn in (square; the circle fills it). */
-const VIEWBOX = 120;
-const CENTRE = VIEWBOX / 2;
-/** Horizontal sampling step when tracing each wave path. Lower = smoother. */
-const SAMPLE_STEP = 6;
-
-/**
- * Per-wave parameters. Each wave is a travelling sine (amplitude/frequency/phase)
- * plus a slower, longer-wavelength term that makes the line "slosh" like liquid.
- */
-interface WaveConfig {
-  colour: string;
-  /** Peak height of the travelling wave, in viewBox units. */
-  amplitude: number;
-  /** Angular frequency of the travelling wave (radians per viewBox unit). */
-  frequency: number;
-  /** How fast the travelling wave scrolls (radians per frame). */
-  phaseSpeed: number;
-  /** Vertical centre offset so the waves stack rather than overlap exactly. */
-  verticalOffset: number;
-  /** Amplitude of the slow sloshing term. */
-  slosh: number;
-  /** Angular frequency of the sloshing term (radians per viewBox unit). */
-  sloshFrequency: number;
-  /** How fast the sloshing term evolves (radians per frame). */
-  sloshSpeed: number;
-}
-
-const WAVES: WaveConfig[] = [
-  {
-    colour: AI_COLOUR_AMBER,
-    amplitude: 11,
-    frequency: 0.085,
-    phaseSpeed: 0.05,
-    verticalOffset: -6,
-    slosh: 6,
-    sloshFrequency: 0.018,
-    sloshSpeed: 0.021,
-  },
-  {
-    colour: AI_COLOUR_PINK,
-    amplitude: 14,
-    frequency: 0.07,
-    phaseSpeed: -0.043,
-    verticalOffset: -2,
-    slosh: 7,
-    sloshFrequency: 0.022,
-    sloshSpeed: -0.017,
-  },
-  {
-    colour: AI_COLOUR_CYAN,
-    amplitude: 13,
-    frequency: 0.095,
-    phaseSpeed: 0.037,
-    verticalOffset: 2,
-    slosh: 5,
-    sloshFrequency: 0.015,
-    sloshSpeed: 0.025,
-  },
-  {
-    colour: AI_COLOUR_VIOLET,
-    amplitude: 10,
-    frequency: 0.06,
-    phaseSpeed: -0.055,
-    verticalOffset: 6,
-    slosh: 8,
-    sloshFrequency: 0.025,
-    sloshSpeed: -0.013,
-  },
-];
-
-const wavePathsMarkup = WAVES.map(
-  (w, i) => `<path class="wave" data-wave="${i}" stroke="${w.colour}" />`,
-).join('');
-
-/**
- * Animated "waves inside a circle" loading indicator — coloured sine waves that
- * slosh like glowing liquid inside a circular window, ringed by a rotating
- * gradient halo (the same effect as `<ai-halo-overlay>`).
- *
- * Visual sibling of the dots loading indicator; the two are interchangeable
- * styles of the same "assistant is working" state.
- *
- * @example
- * ```html
- * <ai-waves-indicator size="56"></ai-waves-indicator>
- * ```
- *
- * @beta
- */
-@customElement({
-  name: 'ai-waves-indicator',
-  template: html<AiWavesIndicator>`
-    <div class="window" role="img" aria-label="Assistant is working">
-      <svg class="waves" viewBox="0 0 ${VIEWBOX} ${VIEWBOX}" preserveAspectRatio="none">
-        <defs>
-          <filter id="wave-glow" x="-20%" y="-20%" width="140%" height="140%">
-            <feGaussianBlur stdDeviation="1.6" result="blur" />
-            <feMerge>
-              <feMergeNode in="blur" />
-              <feMergeNode in="SourceGraphic" />
-            </feMerge>
-          </filter>
-        </defs>
-        <g filter="url(#wave-glow)">${wavePathsMarkup}</g>
-      </svg>
-      <ai-halo-overlay active border-size="2" glow-opacity="0.5" glow-spread="55"></ai-halo-overlay>
-    </div>
-  `,
-  styles: css`
-    :host {
-      display: inline-block;
-      width: var(--waves-size, ${WAVES_DEFAULT_SIZE_CSS});
-      height: var(--waves-size, ${WAVES_DEFAULT_SIZE_CSS});
-    }
-
-    .window {
-      position: relative;
-      width: 100%;
-      height: 100%;
-      border-radius: 50%;
-      overflow: hidden;
-      background: radial-gradient(circle at 50% 32%, #2b3140 0%, #11141c 55%, #05070c 100%);
-    }
-
-    .waves {
-      position: absolute;
-      inset: 0;
-      width: 100%;
-      height: 100%;
-    }
-
-    .wave {
-      fill: none;
-      stroke-width: 2;
-      stroke-linecap: round;
-      stroke-linejoin: round;
-    }
-  `,
-})
-export class AiWavesIndicator extends GenesisElement {
-  /** Diameter of the circular window in px. Default: 56. */
-  @attr({ converter: { fromView: Number, toView: String } }) size: number = WAVES_DEFAULT_SIZE;
-
-  sizeChanged() {
-    this.style.setProperty('--waves-size', `${this.size}px`);
-  }
-
-  // A rAF loop drives the wave paths for the same reason `<ai-halo-overlay>`
-  // hand-drives its rotation: a pure-CSS approach can't produce per-frame sine
-  // geometry, and SMIL/`<animate>` can't express the combined travel + slosh.
-
-  private frame = 0;
-  private animFrame?: number;
-  private wavePaths?: SVGPathElement[];
-
-  connectedCallback() {
-    super.connectedCallback();
-    this.tick();
-  }
-
-  disconnectedCallback() {
-    super.disconnectedCallback();
-    if (this.animFrame !== undefined) {
-      cancelAnimationFrame(this.animFrame);
-      this.animFrame = undefined;
-    }
-  }
-
-  private tick() {
-    if (!this.wavePaths) {
-      const paths = this.shadowRoot?.querySelectorAll<SVGPathElement>('.wave');
-      if (paths?.length) this.wavePaths = Array.from(paths);
-    }
-    this.wavePaths?.forEach((path, i) => {
-      path.setAttribute('d', AiWavesIndicator.buildWavePath(WAVES[i], this.frame));
-    });
-    this.frame += 1;
-    this.animFrame = requestAnimationFrame(() => this.tick());
-  }
-
-  /** Trace one wave's polyline `d` attribute for the given frame. */
-  private static buildWavePath(cfg: WaveConfig, frame: number): string {
-    const segments: string[] = [];
-    for (let x = 0; x <= VIEWBOX; x += SAMPLE_STEP) {
-      const y =
-        CENTRE +
-        cfg.verticalOffset +
-        cfg.amplitude * Math.sin(x * cfg.frequency + frame * cfg.phaseSpeed) +
-        cfg.slosh * Math.sin(x * cfg.sloshFrequency + frame * cfg.sloshSpeed);
-      segments.push(`${x},${y.toFixed(2)}`);
-    }
-    return `M ${segments.join(' L ')}`;
-  }
-}
-
-// Ensure the halo overlay used for the ring is registered alongside this component.
-avoidTreeShaking(AiHaloOverlay);

package/src/utils/animation-exclusivity.test.ts

@@ -1,53 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AiAssistantAnimation } from '../main/main.types';
-import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
-
-const suite = createLogicSuite('resolveExclusiveLoadingStyle');
-
-suite('leaves a selection with only the dots loading style untouched', () => {
-  const next: AiAssistantAnimation[] = ['loading', 'halo'];
-  assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['loading', 'halo']);
-});
-
-suite('leaves a selection with only the waves loading style untouched', () => {
-  const next: AiAssistantAnimation[] = ['waves', 'halo'];
-  assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['waves', 'halo']);
-});
-
-suite('leaves a selection with no loading style untouched', () => {
-  assert.equal(resolveExclusiveLoadingStyle(['halo'], []), ['halo']);
-});
-
-suite('drops dots when waves was just added on top of dots', () => {
-  // Previously dots was on; user ticks waves → waves wins, dots removed.
-  const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['loading', 'halo']);
-  assert.equal(result, ['waves', 'halo']);
-});
-
-suite('drops waves when dots was just added on top of waves', () => {
-  // Previously waves was on; user ticks dots → dots wins, waves removed.
-  const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['waves', 'halo']);
-  assert.equal(result, ['loading', 'halo']);
-});
-
-suite('preserves the order of the surviving selection', () => {
-  const result = resolveExclusiveLoadingStyle(['halo', 'loading', 'waves'], ['halo', 'loading']);
-  // waves was just added → loading dropped; halo and waves keep their order.
-  assert.equal(result, ['halo', 'waves']);
-});
-
-suite('falls back to dots when both are present with no prior state (e.g. bad config)', () => {
-  const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], []);
-  assert.equal(result, ['loading', 'halo']);
-});
-
-suite('falls back to dots when both were already present (neither newly added)', () => {
-  const result = resolveExclusiveLoadingStyle(['loading', 'waves'], ['loading', 'waves', 'halo']);
-  assert.equal(result, ['loading']);
-});
-
-suite('handles an empty selection', () => {
-  assert.equal(resolveExclusiveLoadingStyle([], ['loading']), []);
-});
-
-suite.run();

package/src/utils/animation-exclusivity.ts

@@ -1,40 +0,0 @@
-import type { AiAssistantAnimation } from '../main/main.types';
-import { LOADING_STYLE_ANIMATIONS } from '../main/main.types';
-
-/**
- * Enforces that at most one loading-indicator style (dots vs. waves) is enabled
- * at a time. The two are alternative presentations of the same "assistant is
- * working" state, so selecting one must deselect the other.
- *
- * The settings control is a multiselect (checkboxes), which permits selecting
- * both; this resolver makes the loading-style group behave like a radio group
- * by dropping the previously-selected style whenever a new one is added.
- *
- * @param next - The freshly-selected animation list (e.g. emitted by the
- *   multiselect, or read from consumer config).
- * @param previous - The animation list in effect before this change. Used to
- *   work out which loading style was just added so the other can be dropped.
- *   Pass `[]` when resolving an initial/config value with no prior state.
- * @returns `next` with at most one loading style retained. When both are
- *   present and neither is newly added (e.g. a misconfigured `enabled` list),
- *   the first entry of `LOADING_STYLE_ANIMATIONS` (dots) wins.
- *
- * @internal
- */
-export function resolveExclusiveLoadingStyle(
-  next: AiAssistantAnimation[],
-  previous: AiAssistantAnimation[] = [],
-): AiAssistantAnimation[] {
-  const selectedStyles = LOADING_STYLE_ANIMATIONS.filter((style) => next.includes(style));
-  if (selectedStyles.length <= 1) {
-    return next;
-  }
-  // Both styles selected — keep whichever was just added (absent from
-  // `previous`); fall back to the first declared style on ambiguity.
-  const justAdded = selectedStyles.find((style) => !previous.includes(style)) ?? selectedStyles[0];
-  return next.filter(
-    (animation) =>
-      animation === justAdded ||
-      !(LOADING_STYLE_ANIMATIONS as readonly AiAssistantAnimation[]).includes(animation),
-  );
-}