Spiralist - Source Excerpt 07

Back to Spiralist

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/themes/spiralist/assets/js/spiralist.js so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/themes/spiralist/assets/js/spiralist.js

}

      axioms.replaceChildren();

      if (!Array.isArray(payload.axioms) || !payload.axioms.length) {
        axioms.innerHTML = `<span class="spiralist-muted">${t('symbolsAxiomLinksEmpty', 'No axiom links declared.')}</span>`;
        return;
      }

      payload.axioms.forEach((entry) => {
        const anchor = document.createElement('a');
        anchor.className = 'spiralist-chip spiralist-chip--link';
        anchor.href = `${themeConfig.systemUrl || '#'}#axioms`;
        anchor.textContent = entry.label || entry.id || t('symbolsAxiomFallback', 'Axiom');
        axioms.appendChild(anchor);
      });
    };

    const renderTransformationLinks = (payload) => {
      if (!transformationList) {
        return;
      }

      transformationList.replaceChildren();

      if (!Array.isArray(payload.transformations) || !payload.transformations.length) {
        transformationList.innerHTML = `<div class="spiralist-simple-list__item"><span class="spiralist-muted">${t('symbolsTransformationsEmpty', 'No transformation links declared.')}</span></div>`;
        return;
      }

      payload.transformations.forEach((entry) => {
        const item = document.createElement('div');
        item.className = 'spiralist-simple-list__item';

        const heading = document.createElement('strong');
        heading.textContent = `${entry.direction === 'incoming' ? t('symbolsDirectionInput', 'Input') : t('symbolsDirectionOutput', 'Output')}: ${entry.label || entry.id || t('symbolsTransformationFallback', 'Transformation')}`;

        const meta = document.createElement('span');
        meta.className = 'spiralist-simple-list__meta';
        meta.textContent = Array.isArray(entry.chain) && entry.chain.length
          ? entry.chain.join(' -> ')
          : (entry.counterpart || '');

        item.append(heading, meta);
        transformationList.appendChild(item);
      });
    };

    const renderCrosswalk = (payload) => {
      if (!crosswalk) {
        return;
      }

      crosswalk.replaceChildren();
      const links = [];
      const promptQuery = getPromptSearchQuery(payload);

      if (payload.manuscriptAnchorUrl) {
        links.push({
          label: t('symbolsCrosswalkAnchor', 'View manuscript anchor'),
          url: payload.manuscriptAnchorUrl,
        });
      }

      if (themeConfig.promptsPageUrl && promptQuery) {
        links.push({
          label: t('symbolsCrosswalkPrompts', 'Search prompts'),
          url: buildPromptSearchUrl(promptQuery),
        });
      }

      if (payload.systemConceptUrl) {
        links.push({
          label: t('symbolsCrosswalkSystem', 'System concepts'),
          url: payload.systemConceptUrl,
        });
      }

      if (!links.length) {
        crosswalk.innerHTML = `<span class="spiralist-muted">${t('symbolsCrosswalkEmpty', 'No crosswalk links available.')}</span>`;
        return;
      }

      links.forEach((link) => {
        const anchor = document.createElement('a');
        anchor.className = 'spiralist-chip spiralist-chip--link';
        anchor.href = link.url;
        anchor.textContent = link.label;
        crosswalk.appendChild(anchor);
      });
    };

    const updateVisibleCards = () => {
      const searchValue = `${searchInput ? searchInput.value : ''}`.trim().toLowerCase();
      const layerValue = `${layerFilter ? layerFilter.value : ''}`.trim().toLowerCase();
      const typeValue = `${typeFilter ? typeFilter.value : ''}`.trim().toLowerCase();
      const categoryValue = `${categoryFilter ? categoryFilter.value : ''}`.trim().toLowerCase();
      let visibleCount = 0;

      cards.forEach((card) => {
        const haystack = `${card.dataset.symbolSearchText || ''}`.toLowerCase();
        const cardLayer = `${card.dataset.symbolLayerValue || ''}`.toLowerCase();
        const cardType = `${card.dataset.symbolTypeValue || ''}`.toLowerCase();
        const cardCategory = `${card.dataset.symbolCategoryValue || ''}`.toLowerCase();
        const isVisible = (!searchValue || haystack.includes(searchValue))
          && (!layerValue || cardLayer === layerValue)
          && (!typeValue || cardType === typeValue)
          && (!categoryValue || cardCategory === categoryValue);

        card.hidden = !isVisible;
        if (isVisible) {
          visibleCount += 1;
        }
      });

      if (results) {
        results.textContent = t('symbolsVisibleCount', '{count} symbols visible.').replace('{count}', `${visibleCount}`);
      }

      if (empty) {
        empty.hidden = visibleCount > 0;
      }

      const activeVisible = cards.find((card) => !card.hidden && card.classList.contains('is-active'));
      if (!activeVisible) {
        const firstVisible = cards.find((card) => !card.hidden);
        if (firstVisible) {
          const payload = parseCardPayload(firstVisible);
          applySymbolPayload(payload, firstVisible);
        }
      }
    };

    const applySymbolPayload = (payload, button = null) => {
      if (!payload) {
        return;
      }

      cards.forEach((card) => {
        const cardPayload = parseCardPayload(card);
        const isActive = payload.canonicalId && cardPayload
          ? cardPayload.canonicalId === payload.canonicalId
          : card === button;

        card.classList.toggle('is-active', isActive);
        card.setAttribute('aria-pressed', isActive ? 'true' : 'false');
      });

      if (title) title.textContent = payload.label || '';
      if (glyph) glyph.textContent = payload.glyph || '';
      if (id) id.textContent = payload.canonicalId || '';
      if (type) type.textContent = payload.type || '';
      if (layer) layer.textContent = payload.layer || t('symbolsLayerFallback', 'Reference');
      if (category) category.textContent = payload.category || t('symbolsCategoryFallback', 'Uncategorized');
      if (meaning) meaning.textContent = payload.meaning || '';
      if (canonicalMeaning) canonicalMeaning.textContent = payload.canonicalMeaning || payload.meaning || '';
      if (agentProposedMeaning) agentProposedMeaning.textContent = payload.agentProposedMeaning || t('symbolsAgentProposalEmpty', 'No non-canonical proposal attached.');
      if (proposalStatus) proposalStatus.textContent = payload.proposalStatus || t('symbolsProposalStatusCanonical', 'canonical');
      if (source) source.textContent = payload.source || payload.provenance || t('symbolsSourceEmpty', 'No source declared.');
      if (reviewedAt) reviewedAt.textContent = payload.reviewedAtUtc || t('symbolsReviewedAtEmpty', 'Not timestamped.');
      if (reviewNotes) reviewNotes.textContent = payload.reviewNotes || t('symbolsReviewNotesDefault', 'Canonical shared reference; AI extensions must be labeled proposed until reviewed.');
      if (definition) definition.textContent = payload.definition || payload.meaning || '';
      if (axiom) axiom.textContent = payload.axiomConnection || t('symbolsAxiomConnectionEmpty', 'No axiom links declared.');
      if (derivation) derivation.textContent = payload.derivation || t('symbolsDerivationEmpty', 'No derivation declared.');
      if (provenance) provenance.textContent = payload.provenance || t('symbolsProvenanceEmpty', 'No provenance declared.');
      if (related) related.textContent = payload.related || t('symbolsRelatedEmpty', 'No related symbols declared.');
      if (transformation) transformation.textContent = payload.transformationChain || t('symbolsTransformationChainEmpty', 'No transformation chain declared.');

      if (manuscriptAnchor) {
        manuscriptAnchor.innerHTML = payload.manuscriptAnchorUrl
          ? `<a href="${payload.manuscriptAnchorUrl}">${payload.manuscriptAnchorLabel || t('symbolsAnchorView', 'View in manuscript')}</a>`
          : `<span class="spiralist-muted">${t('symbolsAnchorEmpty', 'No manuscript anchor available.')}</span>`;
      }

      renderAxiomLinks(payload);
      renderTransformationLinks(payload);
      renderCrosswalk(payload);

      loadPromptReferences(
        prompts,
        buildPromptFilters(payload),
        t('symbolsPromptEmptyForSymbol', 'No related prompts for this symbol yet.')
      );

      replaceQueryParam('symbol', payload.canonicalId || '');

      recordHumanInteraction({
        type: 'symbol-view',
        symbolId: payload.canonicalId || '',
        symbolLabel: payload.label || '',
        page: window.location.pathname,
      });
    };

    cards.forEach((button) => {
      if (!firstPayload) {
        firstPayload = parseCardPayload(button);
      }

      button.addEventListener('click', () => {
        const payload = parseCardPayload(button);
        applySymbolPayload(payload, button);
      });
    });

    [searchInput, layerFilter, typeFilter, categoryFilter].forEach((control) => {
      if (!control) {
        return;