Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

5.9 KB
Raw Blame
'use client'

import type { RecommendedAppResponse } from '@dify/contracts/api/console/explore/types.gen'
import { cn } from '@langgenius/dify-ui/cn'
import { useQuery, useSuspenseQuery } from '@tanstack/react-query'
import * as React from 'react'
import { useEffect, useRef, useState } from 'react'
import { useTranslation } from 'react-i18next'
import { useLocale } from '#i18n'
import { MAIN_NAV_APP_CARD_GRID_CLASS_NAME } from '@/app/components/main-nav/app-card-grid'
import { systemFeaturesQueryOptions } from '@/features/system-features/client'
import { consoleQuery } from '@/service/console'
import LearnDifyItem from './item'
import { useLearnDifyHiddenValue, useSetLearnDifyHidden } from './storage'

type LearnDifyProps = {
  canCreate?: boolean
  className?: string
  dismissible?: boolean
  forceVisible?: boolean
  itemLimit?: number
  loadingFallback?: React.ReactNode
  onCreate?: (app: RecommendedAppResponse) => void
  onTry?: (app: RecommendedAppResponse) => void
  showDescription?: boolean
  stepByStepTourTarget?: string
  title?: string
}

type LearnDifyContentProps = LearnDifyProps & {
  onHide?: () => void
}

const LearnDifyContent = ({
  canCreate = false,
  className,
  itemLimit,
  loadingFallback = null,
  onHide,
  onCreate,
  onTry,
  showDescription = true,
  stepByStepTourTarget,
  title,
}: LearnDifyContentProps) => {
  const { t } = useTranslation(['explore'])
  const locale = useLocale()
  const [isClosing, setIsClosing] = useState(false)
  const [collapseTransform, setCollapseTransform] = useState<string>()
  const hideTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
  const sectionRef = useRef<HTMLElement>(null)
  const { data: learnDifyItems = [], isLoading } = useQuery(
    consoleQuery.explore.apps.learnDify.get.queryOptions({
      input: { query: { language: locale } },
      select: (response) =>
        [...response.recommended_apps].sort((a, b) => (a.position ?? 0) - (b.position ?? 0)),
    }),
  )

  useEffect(() => {
    return () => {
      if (hideTimerRef.current) clearTimeout(hideTimerRef.current)
    }
  }, [])

  const handleHide = () => {
    const sectionRect = sectionRef.current?.getBoundingClientRect()
    const helpTargetRect = document
      .querySelector('[data-learn-dify-help-target]')
      ?.getBoundingClientRect()
    if (sectionRect && helpTargetRect) {
      const sectionCenterX = sectionRect.left + sectionRect.width / 2
      const sectionCenterY = sectionRect.top + sectionRect.height / 2
      const helpCenterX = helpTargetRect.left + helpTargetRect.width / 2
      const helpCenterY = helpTargetRect.top + helpTargetRect.height / 2

      setCollapseTransform(
        `translate3d(${helpCenterX - sectionCenterX}px, ${helpCenterY - sectionCenterY}px, 0) scale(0.08)`,
      )
    } else {
      setCollapseTransform('scale(0.08)')
    }
    setIsClosing(true)
    hideTimerRef.current = setTimeout(() => {
      onHide?.()
      setIsClosing(false)
      setCollapseTransform(undefined)
    }, 800)
  }

  const visibleItems = itemLimit ? learnDifyItems.slice(0, itemLimit) : learnDifyItems
  const sectionTitle = title ?? t(($) => $['learnDify.title'], { ns: 'explore' })

  if (isLoading) return loadingFallback
  if (visibleItems.length === 0) return null

  return (
    <section
      ref={sectionRef}
      className={cn(
        'px-8 pb-6 transition-[opacity,transform] duration-800 ease-in-out',
        isClosing && 'pointer-events-none relative z-50 opacity-20',
        className,
      )}
      style={
        isClosing ? { transform: collapseTransform, transformOrigin: 'center center' } : undefined
      }
      aria-labelledby="learn-dify-title"
      data-step-by-step-tour-target={stepByStepTourTarget}
    >
      <div className="-mx-4 rounded-2xl bg-background-section p-4">
        <div className="flex items-start justify-between gap-4 pb-2.5">
          <div className="min-w-0">
            <h2
              id="learn-dify-title"
              className="truncate system-xl-medium text-text-primary"
              title={sectionTitle}
            >
              {sectionTitle}
            </h2>
            {showDescription && (
              <p className="mt-0.5 truncate system-xs-regular text-text-tertiary">
                {t(($) => $['learnDify.description'], { ns: 'explore' })}
              </p>
            )}
          </div>
          {onHide && (
            <button
              type="button"
              className="flex size-8 shrink-0 touch-manipulation items-center justify-center rounded-lg text-text-tertiary outline-hidden transition-colors hover:bg-state-base-hover hover:text-text-secondary focus-visible:bg-state-base-hover focus-visible:ring-2 focus-visible:ring-state-accent-solid motion-reduce:transition-none"
              aria-label={t(($) => $['learnDify.hide'], { ns: 'explore' })}
              onClick={handleHide}
            >
              <span className="i-ri-close-line size-4" aria-hidden="true" />
            </button>
          )}
        </div>
        <div className={cn('gap-2.5', MAIN_NAV_APP_CARD_GRID_CLASS_NAME)}>
          {visibleItems.map((item) => (
            <LearnDifyItem
              key={item.app_id}
              canCreate={canCreate}
              item={item}
              onCreate={onCreate}
              onTry={onTry}
            />
          ))}
        </div>
      </div>
    </section>
  )
}

const DismissibleLearnDify = (props: LearnDifyProps) => {
  const hidden = useLearnDifyHiddenValue()
  const setHidden = useSetLearnDifyHidden()

  if (hidden) return null

  return <LearnDifyContent {...props} onHide={() => setHidden(true)} />
}

const LearnDify = (props: LearnDifyProps) => {
  const { data: systemFeatures } = useSuspenseQuery(systemFeaturesQueryOptions())

  if (!systemFeatures.enable_learn_app) return null

  if (props.dismissible === false || props.forceVisible) return <LearnDifyContent {...props} />

  return <DismissibleLearnDify {...props} />
}

export default React.memo(LearnDify)