fastapi-voyager 0.15.2__py3-none-any.whl → 0.15.3__py3-none-any.whl

fastapi_voyager/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.15.2"
+__version__ = "0.15.3"

fastapi_voyager/web/store.js

@@ -1,10 +1,6 @@
 const { reactive } = window.Vue
 
 const state = reactive({
-  item: {
-    count: 0,
-  },
-
   version: "",
   config: {
     initial_page_policy: "first",
@@ -15,7 +11,8 @@ const state = reactive({
   mode: "voyager", // voyager / er-diagram
 
   previousTagRoute: {
-    // for shift + click, store previous tag/route, and populate back when needed
+    // Store the last non-search tag/route selection for restoration when clearing search
+    // Used by resetSearch to return to the state before entering search mode
     hasValue: false,
     tag: null,
     routeId: null,
@@ -65,6 +62,9 @@ const state = reactive({
     fieldOptions: [],
   },
 
+  // cache all schema options for filtering
+  allSchemaOptions: [],
+
   // route information
   routeDetail: {
     show: false,
@@ -105,13 +105,425 @@ const state = reactive({
   },
 })
 
-const mutations = {
-  increment() {
-    state.item.count += 1
+const getters = {
+  /**
+   * Find tag name by route ID
+   * Used to determine which tag a route belongs to
+   */
+  findTagByRoute(routeId) {
+    return (
+      state.leftPanel.tags.find((tag) => (tag.routes || []).some((route) => route.id === routeId))
+        ?.name || null
+    )
+  },
+}
+
+const actions = {
+  /**
+   * Read tag and route from URL query parameters
+   * @returns {{ tag: string|null, route: string|null }}
+   */
+  readQuerySelection() {
+    if (typeof window === "undefined") {
+      return { tag: null, route: null }
+    }
+    const params = new URLSearchParams(window.location.search)
+    return {
+      tag: params.get("tag") || null,
+      route: params.get("route") || null,
+    }
+  },
+
+  /**
+   * Sync current tag and route selection to URL
+   * Updates browser URL without reloading the page
+   */
+  syncSelectionToUrl() {
+    if (typeof window === "undefined") {
+      return
+    }
+    const params = new URLSearchParams(window.location.search)
+    if (state.leftPanel.tag) {
+      params.set("tag", state.leftPanel.tag)
+    } else {
+      params.delete("tag")
+    }
+    if (state.leftPanel.routeId) {
+      params.set("route", state.leftPanel.routeId)
+    } else {
+      params.delete("route")
+    }
+    const hash = window.location.hash || ""
+    const search = params.toString()
+    const base = window.location.pathname
+    const newUrl = search ? `${base}?${search}${hash}` : `${base}${hash}`
+    window.history.replaceState({}, "", newUrl)
+  },
+
+  /**
+   * Apply selection from URL query parameters to state
+   * @param {{ tag: string|null, route: string|null }} selection
+   * @returns {boolean} - true if any selection was applied
+   */
+  applySelectionFromQuery(selection) {
+    let applied = false
+    if (selection.tag && state.leftPanel.tags.some((tag) => tag.name === selection.tag)) {
+      state.leftPanel.tag = selection.tag
+      state.leftPanel._tag = selection.tag
+      applied = true
+    }
+    if (selection.route && state.graph.routeItems?.[selection.route]) {
+      state.leftPanel.routeId = selection.route
+      applied = true
+      const inferredTag = getters.findTagByRoute(selection.route)
+      if (inferredTag) {
+        state.leftPanel.tag = inferredTag
+        state.leftPanel._tag = inferredTag
+      }
+    }
+    return applied
+  },
+
+  /**
+   * Restore full tags from cache
+   * Used when resetting search mode
+   */
+  loadFullTags() {
+    state.leftPanel.tags = state.leftPanel.fullTagsCache
+  },
+
+  /**
+   * Populate field options based on selected schema
+   * @param {string} schemaId - Schema ID
+   */
+  populateFieldOptions(schemaId) {
+    if (!schemaId) {
+      state.search.fieldOptions = []
+      state.search.fieldName = null
+      return
+    }
+    const schema = state.graph.schemaMap?.[schemaId]
+    if (!schema) {
+      state.search.fieldOptions = []
+      state.search.fieldName = null
+      return
+    }
+    const fields = Array.isArray(schema.fields) ? schema.fields.map((f) => f.name) : []
+    state.search.fieldOptions = fields
+    if (!fields.includes(state.search.fieldName)) {
+      state.search.fieldName = null
+    }
+  },
+
+  /**
+   * Rebuild schema options from schema map
+   * Should be called when schema map changes
+   */
+  rebuildSchemaOptions() {
+    const dict = state.graph.schemaMap || {}
+    const opts = Object.values(dict).map((s) => ({
+      label: s.name,
+      desc: s.id,
+      value: s.id,
+    }))
+    state.allSchemaOptions = opts
+    state.search.schemaOptions = opts.slice()
+    this.populateFieldOptions(state.search.schemaName)
+  },
+
+  /**
+   * Load tags based on search criteria
+   * @returns {Promise<void>}
+   */
+  async loadSearchedTags() {
+    try {
+      const payload = {
+        schema_name: state.search.schemaName,
+        schema_field: state.search.fieldName || null,
+        show_fields: state.filter.showFields,
+        brief: state.filter.brief,
+        hide_primitive_route: state.filter.hidePrimitiveRoute,
+        show_module: state.filter.showModule,
+      }
+      const res = await fetch("dot-search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      })
+      if (res.ok) {
+        const data = await res.json()
+        const tags = Array.isArray(data.tags) ? data.tags : []
+        state.leftPanel.tags = tags
+      }
+    } catch (err) {
+      console.error("dot-search failed", err)
+    }
+  },
+
+  /**
+   * Load initial data from API
+   * @param {Function} onGenerate - Callback to generate graph after load
+   * @param {Function} renderBasedOnInitialPolicy - Callback to render based on policy
+   * @returns {Promise<void>}
+   */
+  async loadInitial(onGenerate, renderBasedOnInitialPolicy) {
+    state.initializing = true
+    try {
+      const res = await fetch("dot")
+      const data = await res.json()
+      const tags = Array.isArray(data.tags) ? data.tags : []
+      state.leftPanel.tags = tags
+      // Cache the full tags for later use (e.g., resetSearch)
+      state.leftPanel.fullTagsCache = tags
+
+      const schemasArr = Array.isArray(data.schemas) ? data.schemas : []
+      // Build dict keyed by id for faster lookups and simpler prop passing
+      const schemaMap = Object.fromEntries(schemasArr.map((s) => [s.id, s]))
+      state.graph.schemaMap = schemaMap
+      state.graph.schemaKeys = new Set(Object.keys(schemaMap))
+      state.graph.routeItems = data.tags
+        .map((t) => t.routes)
+        .flat()
+        .reduce((acc, r) => {
+          acc[r.id] = r
+          return acc
+        }, {})
+      state.modeControl.briefModeEnabled = data.enable_brief_mode || false
+      state.version = data.version || ""
+      state.swagger.url = data.swagger_url || null
+      state.config.has_er_diagram = data.has_er_diagram || false
+      state.config.enable_pydantic_resolve_meta = data.enable_pydantic_resolve_meta || false
+
+      this.rebuildSchemaOptions()
+
+      const querySelection = this.readQuerySelection()
+      const restoredFromQuery = this.applySelectionFromQuery(querySelection)
+      if (restoredFromQuery) {
+        this.syncSelectionToUrl()
+        onGenerate()
+        return
+      } else {
+        state.config.initial_page_policy = data.initial_page_policy
+        renderBasedOnInitialPolicy()
+      }
+
+      // default route options placeholder
+    } catch (e) {
+      console.error("Initial load failed", e)
+    } finally {
+      state.initializing = false
+    }
+  },
+
+  /**
+   * Filter schema options based on search text
+   * Used by Quasar select component's filter function
+   * @param {string} val - Search text
+   * @param {Function} update - Quasar update callback
+   */
+  filterSearchSchemas(val, update) {
+    const needle = (val || "").toLowerCase()
+    update(() => {
+      if (!needle) {
+        state.search.schemaOptions = state.allSchemaOptions.slice()
+        return
+      }
+      state.search.schemaOptions = state.allSchemaOptions.filter((option) =>
+        option.label.toLowerCase().includes(needle)
+      )
+    })
+  },
+
+  /**
+   * Handle schema selection change
+   * Updates state and triggers search if a schema is selected
+   * @param {string} val - Selected schema ID
+   * @param {Function} onSearch - Callback to trigger search
+   */
+  onSearchSchemaChange(val, onSearch) {
+    state.search.schemaName = val
+    state.search.mode = false
+    if (!val) {
+      // Clearing the select should only run resetSearch via @clear
+      return
+    }
+    onSearch()
+  },
+
+  /**
+   * Reset detail panels (right drawer and route detail)
+   */
+  resetDetailPanels() {
+    state.rightDrawer.drawer = false
+    state.routeDetail.show = false
+    state.schemaDetail.schemaCodeName = ""
+  },
+
+  /**
+   * Reset left panel selection and regenerate
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  onReset(onGenerate) {
+    state.leftPanel.tag = null
+    state.leftPanel._tag = null
+    state.leftPanel.routeId = null
+    this.syncSelectionToUrl()
+    onGenerate()
+  },
+
+  /**
+   * Toggle pydantic resolve meta visibility
+   * @param {boolean} val - New value
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  togglePydanticResolveMeta(val, onGenerate) {
+    state.modeControl.pydanticResolveMetaEnabled = val
+    try {
+      localStorage.setItem("pydantic_resolve_meta", JSON.stringify(val))
+    } catch (e) {
+      console.warn("Failed to save pydantic_resolve_meta to localStorage", e)
+    }
+    onGenerate()
+  },
+
+  /**
+   * Toggle show module clustering
+   * @param {boolean} val - New value
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  toggleShowModule(val, onGenerate) {
+    state.filter.showModule = val
+    try {
+      localStorage.setItem("show_module_cluster", JSON.stringify(val))
+    } catch (e) {
+      console.warn("Failed to save show_module_cluster to localStorage", e)
+    }
+    onGenerate()
+  },
+
+  /**
+   * Toggle show fields option
+   * @param {string} field - Field display option ("single", "object", "all")
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  toggleShowField(field, onGenerate) {
+    state.filter.showFields = field
+    onGenerate(false)
+  },
+
+  /**
+   * Toggle brief mode
+   * @param {boolean} val - New value
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  toggleBrief(val, onGenerate) {
+    state.filter.brief = val
+    try {
+      localStorage.setItem("brief_mode", JSON.stringify(val))
+    } catch (e) {
+      console.warn("Failed to save brief_mode to localStorage", e)
+    }
+    onGenerate()
+  },
+
+  /**
+   * Toggle hide primitive route
+   * @param {boolean} val - New value
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  toggleHidePrimitiveRoute(val, onGenerate) {
+    state.filter.hidePrimitiveRoute = val
+    try {
+      localStorage.setItem("hide_primitive", JSON.stringify(val))
+    } catch (e) {
+      console.warn("Failed to save hide_primitive to localStorage", e)
+    }
+    onGenerate(false)
+  },
+
+  /**
+   * Render based on initial page policy
+   * @param {Function} onGenerate - Callback to regenerate graph
+   */
+  renderBasedOnInitialPolicy(onGenerate) {
+    switch (state.config.initial_page_policy) {
+      case "full":
+        onGenerate()
+        return
+      case "empty":
+        return
+      case "first":
+        state.leftPanel.tag = state.leftPanel.tags.length > 0 ? state.leftPanel.tags[0].name : null
+        state.leftPanel._tag = state.leftPanel.tag
+        this.syncSelectionToUrl()
+        onGenerate()
+        return
+    }
+  },
+
+  /**
+   * Build payload for Voyager rendering
+   * @returns {Object} Payload for dot API
+   */
+  buildVoyagerPayload() {
+    const activeSchema = state.search.mode ? state.search.schemaName : null
+    const activeField = state.search.mode ? state.search.fieldName : null
+    return {
+      tags: state.leftPanel.tag ? [state.leftPanel.tag] : null,
+      schema_name: activeSchema || null,
+      schema_field: activeField || null,
+      route_name: state.leftPanel.routeId || null,
+      show_fields: state.filter.showFields,
+      brief: state.filter.brief,
+      hide_primitive_route: state.filter.hidePrimitiveRoute,
+      show_module: state.filter.showModule,
+      show_pydantic_resolve_meta: state.modeControl.pydanticResolveMetaEnabled,
+    }
+  },
+
+  /**
+   * Build payload for ER Diagram rendering
+   * @returns {Object} Payload for er-diagram API
+   */
+  buildErDiagramPayload() {
+    return {
+      show_fields: state.filter.showFields,
+      show_module: state.filter.showModule,
+    }
+  },
+
+  /**
+   * Restore search state and return whether to regenerate
+   * @returns {boolean} - true if should regenerate with previous selection
+   */
+  resetSearchState() {
+    state.search.mode = false
+    const hadPreviousValue = state.previousTagRoute.hasValue
+
+    if (hadPreviousValue) {
+      state.leftPanel.tag = state.previousTagRoute.tag
+      state.leftPanel._tag = state.previousTagRoute.tag
+      state.leftPanel.routeId = state.previousTagRoute.routeId
+      // Clear the saved state
+      state.previousTagRoute.hasValue = false
+    } else {
+      state.leftPanel.tag = null
+      state.leftPanel._tag = null
+      state.leftPanel.routeId = null
+    }
+
+    this.syncSelectionToUrl()
+    this.loadFullTags()
+
+    return hadPreviousValue
   },
 }
 
+const mutations = {}
+
 export const store = {
   state,
+  getters,
+  actions,
   mutations,
 }

fastapi_voyager/web/vue-main.js

@@ -22,7 +22,6 @@ function loadToggleState(key, defaultValue = false) {
 const app = createApp({
   setup() {
     let graphUI = null
-    const allSchemaOptions = ref([])
     const erDiagramLoading = ref(false)
     const erDiagramCache = ref("")
 
@@ -42,20 +41,13 @@ const app = createApp({
       graphUI = new GraphUI("#graph", {
         onSchemaShiftClick: (id) => {
           if (store.state.graph.schemaKeys.has(id)) {
-            // Only save current tag/route if we're not already in search mode
-            // This prevents overwriting the saved state with null values
-            if (!store.state.previousTagRoute.hasValue && !store.state.search.mode) {
-              store.state.previousTagRoute.tag = store.state.leftPanel.tag
-              store.state.previousTagRoute.routeId = store.state.leftPanel.routeId
-              store.state.previousTagRoute.hasValue = true
-            }
             store.state.search.mode = true
             store.state.search.schemaName = id
             onSearch()
           }
         },
         onSchemaClick: (id) => {
-          resetDetailPanels()
+          store.actions.resetDetailPanels()
           if (store.state.graph.schemaKeys.has(id)) {
             store.state.schemaDetail.schemaCodeName = id
             store.state.rightDrawer.drawer = true
@@ -66,257 +58,44 @@ const app = createApp({
           }
         },
         resetCb: () => {
-          resetDetailPanels()
+          store.actions.resetDetailPanels()
         },
       })
     }
 
-    function rebuildSchemaOptions() {
-      const dict = store.state.graph.schemaMap || {}
-      const opts = Object.values(dict).map((s) => ({
-        label: s.name,
-        desc: s.id,
-        value: s.id,
-      }))
-      allSchemaOptions.value = opts
-      store.state.search.schemaOptions = opts.slice()
-      populateFieldOptions(store.state.search.schemaName)
-    }
-
-    function populateFieldOptions(schemaId) {
-      if (!schemaId) {
-        store.state.search.fieldOptions = []
-        store.state.search.fieldName = null
-        return
-      }
-      const schema = store.state.graph.schemaMap?.[schemaId]
-      if (!schema) {
-        store.state.search.fieldOptions = []
-        store.state.search.fieldName = null
-        return
-      }
-      const fields = Array.isArray(schema.fields) ? schema.fields.map((f) => f.name) : []
-      store.state.search.fieldOptions = fields
-      if (!fields.includes(store.state.search.fieldName)) {
-        store.state.search.fieldName = null
-      }
-    }
-
-    function filterSearchSchemas(val, update) {
-      const needle = (val || "").toLowerCase()
-      update(() => {
-        if (!needle) {
-          store.state.search.schemaOptions = allSchemaOptions.value.slice()
-          return
-        }
-        store.state.search.schemaOptions = allSchemaOptions.value.filter((option) =>
-          option.label.toLowerCase().includes(needle)
-        )
-      })
-    }
-
-    function onSearchSchemaChange(val) {
-      store.state.search.schemaName = val
-      store.state.search.mode = false
-      if (!val) {
-        // Clearing the select should only run resetSearch via @clear
-        return
-      }
-      onSearch()
-    }
-
-    function readQuerySelection() {
-      if (typeof window === "undefined") {
-        return { tag: null, route: null }
-      }
-      const params = new URLSearchParams(window.location.search)
-      return {
-        tag: params.get("tag") || null,
-        route: params.get("route") || null,
-      }
-    }
-
-    function findTagByRoute(routeId) {
-      return (
-        store.state.leftPanel.tags.find((tag) =>
-          (tag.routes || []).some((route) => route.id === routeId)
-        )?.name || null
-      )
-    }
-
-    function syncSelectionToUrl() {
-      if (typeof window === "undefined") {
-        return
-      }
-      const params = new URLSearchParams(window.location.search)
-      if (store.state.leftPanel.tag) {
-        params.set("tag", store.state.leftPanel.tag)
-      } else {
-        params.delete("tag")
-      }
-      if (store.state.leftPanel.routeId) {
-        params.set("route", store.state.leftPanel.routeId)
-      } else {
-        params.delete("route")
-      }
-      const hash = window.location.hash || ""
-      const search = params.toString()
-      const base = window.location.pathname
-      const newUrl = search ? `${base}?${search}${hash}` : `${base}${hash}`
-      window.history.replaceState({}, "", newUrl)
-    }
-
-    function applySelectionFromQuery(selection) {
-      let applied = false
-      if (selection.tag && store.state.leftPanel.tags.some((tag) => tag.name === selection.tag)) {
-        store.state.leftPanel.tag = selection.tag
-        store.state.leftPanel._tag = selection.tag
-        applied = true
-      }
-      if (selection.route && store.state.graph.routeItems?.[selection.route]) {
-        store.state.leftPanel.routeId = selection.route
-        applied = true
-        const inferredTag = findTagByRoute(selection.route)
-        if (inferredTag) {
-          store.state.leftPanel.tag = inferredTag
-          store.state.leftPanel._tag = inferredTag
-        }
-      }
-      return applied
-    }
-
     async function resetSearch() {
-      store.state.search.mode = false
-      const hadPreviousValue = store.state.previousTagRoute.hasValue
-
-      if (hadPreviousValue) {
-        store.state.leftPanel.tag = store.state.previousTagRoute.tag
-        store.state.leftPanel._tag = store.state.previousTagRoute.tag
-        store.state.leftPanel.routeId = store.state.previousTagRoute.routeId
-        store.state.previousTagRoute.hasValue = false
-      } else {
-        store.state.leftPanel.tag = null
-        store.state.leftPanel._tag = null
-        store.state.leftPanel.routeId = null
-      }
-
-      syncSelectionToUrl()
-
-      // Load the full tags from cache (not search results) since we're resetting search
-      loadFullTags()
+      const hadPreviousValue = store.actions.resetSearchState()
 
       // If we restored a previous tag/route, generate with it
       // Otherwise, fall back to initial policy
       if (hadPreviousValue) {
         onGenerate()
       } else {
-        renderBasedOnInitialPolicy()
+        store.actions.renderBasedOnInitialPolicy(onGenerate)
       }
     }
 
-    function loadFullTags() {
-      // Restore from cache (set by loadInitial)
-      store.state.leftPanel.tags = store.state.leftPanel.fullTagsCache
-    }
-
     async function onSearch() {
+      // Save current state before entering search mode (only if not already saved)
+      if (!store.state.previousTagRoute.hasValue) {
+        store.state.previousTagRoute.tag = store.state.leftPanel.tag
+        store.state.previousTagRoute.routeId = store.state.leftPanel.routeId
+        store.state.previousTagRoute.hasValue = true
+      }
+
       store.state.search.mode = true
       store.state.leftPanel.tag = null
       store.state.leftPanel._tag = null
       store.state.leftPanel.routeId = null
-      syncSelectionToUrl()
-      await loadSearchedTags()
+      store.actions.syncSelectionToUrl()
+      await store.actions.loadSearchedTags()
       await onGenerate()
     }
-    async function loadSearchedTags() {
-      try {
-        const payload = {
-          schema_name: store.state.search.schemaName,
-          schema_field: store.state.search.fieldName || null,
-          show_fields: store.state.filter.showFields,
-          brief: store.state.filter.brief,
-          hide_primitive_route: store.state.filter.hidePrimitiveRoute,
-          show_module: store.state.filter.showModule,
-        }
-        const res = await fetch("dot-search", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(payload),
-        })
-        if (res.ok) {
-          const data = await res.json()
-          const tags = Array.isArray(data.tags) ? data.tags : []
-          store.state.leftPanel.tags = tags
-        }
-      } catch (err) {
-        console.error("dot-search failed", err)
-      }
-    }
 
     async function loadInitial() {
-      store.state.initializing = true
-      try {
-        const res = await fetch("dot")
-        const data = await res.json()
-        const tags = Array.isArray(data.tags) ? data.tags : []
-        store.state.leftPanel.tags = tags
-        // Cache the full tags for later use (e.g., resetSearch)
-        store.state.leftPanel.fullTagsCache = tags
-
-        const schemasArr = Array.isArray(data.schemas) ? data.schemas : []
-        // Build dict keyed by id for faster lookups and simpler prop passing
-        const schemaMap = Object.fromEntries(schemasArr.map((s) => [s.id, s]))
-        store.state.graph.schemaMap = schemaMap
-        store.state.graph.schemaKeys = new Set(Object.keys(schemaMap))
-        store.state.graph.routeItems = data.tags
-          .map((t) => t.routes)
-          .flat()
-          .reduce((acc, r) => {
-            acc[r.id] = r
-            return acc
-          }, {})
-        store.state.modeControl.briefModeEnabled = data.enable_brief_mode || false
-        store.state.version = data.version || ""
-        store.state.swagger.url = data.swagger_url || null
-        store.state.config.has_er_diagram = data.has_er_diagram || false
-        store.state.config.enable_pydantic_resolve_meta = data.enable_pydantic_resolve_meta || false
-
-        rebuildSchemaOptions()
-
-        const querySelection = readQuerySelection()
-        const restoredFromQuery = applySelectionFromQuery(querySelection)
-        if (restoredFromQuery) {
-          syncSelectionToUrl()
-          onGenerate()
-          return
-        } else {
-          store.state.config.initial_page_policy = data.initial_page_policy
-          renderBasedOnInitialPolicy()
-        }
-
-        // default route options placeholder
-      } catch (e) {
-        console.error("Initial load failed", e)
-      } finally {
-        store.state.initializing = false
-      }
-    }
-
-    async function renderBasedOnInitialPolicy() {
-      switch (store.state.config.initial_page_policy) {
-        case "full":
-          onGenerate()
-          return
-        case "empty":
-          return
-        case "first":
-          store.state.leftPanel.tag =
-            store.state.leftPanel.tags.length > 0 ? store.state.leftPanel.tags[0].name : null
-          store.state.leftPanel._tag = store.state.leftPanel.tag
-          syncSelectionToUrl()
-          onGenerate()
-          return
-      }
+      await store.actions.loadInitial(onGenerate, (cb) =>
+        store.actions.renderBasedOnInitialPolicy(cb)
+      )
     }
 
     async function onGenerate(resetZoom = true) {
@@ -331,21 +110,9 @@ const app = createApp({
     }
 
     async function renderVoyager(resetZoom = true) {
-      const activeSchema = store.state.search.mode ? store.state.search.schemaName : null
-      const activeField = store.state.search.mode ? store.state.search.fieldName : null
       store.state.generating = true
       try {
-        const payload = {
-          tags: store.state.leftPanel.tag ? [store.state.leftPanel.tag] : null,
-          schema_name: activeSchema || null,
-          schema_field: activeField || null,
-          route_name: store.state.leftPanel.routeId || null,
-          show_fields: store.state.filter.showFields,
-          brief: store.state.filter.brief,
-          hide_primitive_route: store.state.filter.hidePrimitiveRoute,
-          show_module: store.state.filter.showModule,
-          show_pydantic_resolve_meta: store.state.modeControl.pydanticResolveMetaEnabled,
-        }
+        const payload = store.actions.buildVoyagerPayload()
         initGraphUI()
         const res = await fetch("dot", {
           method: "POST",
@@ -362,37 +129,10 @@ const app = createApp({
       }
     }
 
-    function resetDetailPanels() {
-      store.state.rightDrawer.drawer = false
-      store.state.routeDetail.show = false
-      store.state.schemaDetail.schemaCodeName = ""
-    }
-
-    async function onReset() {
-      store.state.leftPanel.tag = null
-      store.state.leftPanel._tag = null
-      store.state.leftPanel.routeId = null
-      syncSelectionToUrl()
-      onGenerate()
-    }
-
-    async function togglePydanticResolveMeta(val) {
-      store.state.modeControl.pydanticResolveMetaEnabled = val
-      try {
-        localStorage.setItem("pydantic_resolve_meta", JSON.stringify(val))
-      } catch (e) {
-        console.warn("Failed to save pydantic_resolve_meta to localStorage", e)
-      }
-      onGenerate()
-    }
-
     async function renderErDiagram(resetZoom = true) {
       initGraphUI()
       erDiagramLoading.value = true
-      const payload = {
-        show_fields: store.state.filter.showFields,
-        show_module: store.state.filter.showModule,
-      }
+      const payload = store.actions.buildErDiagramPayload()
       try {
         const res = await fetch("er-diagram", {
           method: "POST",
@@ -447,7 +187,7 @@ const app = createApp({
 
       store.state.rightDrawer.drawer = false
       store.state.routeDetail.show = false
-      syncSelectionToUrl()
+      store.actions.syncSelectionToUrl()
     }
 
     function toggleTagNavigatorCollapse() {
@@ -468,7 +208,7 @@ const app = createApp({
 
     function selectRoute(routeId) {
       // find belonging tag
-      const belongingTag = findTagByRoute(routeId)
+      const belongingTag = store.getters.findTagByRoute(routeId)
       if (belongingTag) {
         store.state.leftPanel.tag = belongingTag
         store.state.leftPanel._tag = belongingTag
@@ -483,45 +223,10 @@ const app = createApp({
       store.state.rightDrawer.drawer = false
       store.state.routeDetail.show = false
       store.state.schemaDetail.schemaCodeName = ""
-      syncSelectionToUrl()
-      onGenerate()
-    }
-
-    function toggleShowModule(val) {
-      store.state.filter.showModule = val
-      try {
-        localStorage.setItem("show_module_cluster", JSON.stringify(val))
-      } catch (e) {
-        console.warn("Failed to save show_module_cluster to localStorage", e)
-      }
+      store.actions.syncSelectionToUrl()
       onGenerate()
     }
 
-    function toggleShowField(field) {
-      store.state.filter.showFields = field
-      onGenerate(false)
-    }
-
-    function toggleBrief(val) {
-      store.state.filter.brief = val
-      try {
-        localStorage.setItem("brief_mode", JSON.stringify(val))
-      } catch (e) {
-        console.warn("Failed to save brief_mode to localStorage", e)
-      }
-      onGenerate()
-    }
-
-    function toggleHidePrimitiveRoute(val) {
-      store.state.filter.hidePrimitiveRoute = val
-      try {
-        localStorage.setItem("hide_primitive", JSON.stringify(val))
-      } catch (e) {
-        console.warn("Failed to save hide_primitive to localStorage", e)
-      }
-      onGenerate(false)
-    }
-
     function startDragDrawer(e) {
       const startX = e.clientX
       const startWidth = store.state.rightDrawer.width
@@ -549,7 +254,7 @@ const app = createApp({
     watch(
       () => store.state.graph.schemaMap,
       () => {
-        rebuildSchemaOptions()
+        store.actions.rebuildSchemaOptions()
       },
       { deep: false }
     )
@@ -573,8 +278,8 @@ const app = createApp({
     watch(
       () => store.state.search.schemaName,
       (schemaId) => {
-        store.state.search.schemaOptions = allSchemaOptions.value.slice()
-        populateFieldOptions(schemaId)
+        store.state.search.schemaOptions = store.state.allSchemaOptions.slice()
+        store.actions.populateFieldOptions(schemaId)
         if (!schemaId) {
           store.state.search.mode = false
         }
@@ -591,21 +296,22 @@ const app = createApp({
       store,
       onSearch,
       resetSearch,
-      filterSearchSchemas,
-      onSearchSchemaChange,
+      filterSearchSchemas: (val, update) => store.actions.filterSearchSchemas(val, update),
+      onSearchSchemaChange: (val) => store.actions.onSearchSchemaChange(val, onSearch),
       toggleTag,
       toggleTagNavigatorCollapse,
-      toggleBrief,
-      toggleHidePrimitiveRoute,
+      toggleBrief: (val) => store.actions.toggleBrief(val, onGenerate),
+      toggleHidePrimitiveRoute: (val) => store.actions.toggleHidePrimitiveRoute(val, onGenerate),
       selectRoute,
       onGenerate,
-      onReset,
-      toggleShowField,
+      onReset: () => store.actions.onReset(onGenerate),
+      toggleShowField: (field) => store.actions.toggleShowField(field, onGenerate),
       startDragDrawer,
-      toggleShowModule,
+      toggleShowModule: (val) => store.actions.toggleShowModule(val, onGenerate),
       onModeChange,
       renderErDiagram,
-      togglePydanticResolveMeta,
+      togglePydanticResolveMeta: (val) => store.actions.togglePydanticResolveMeta(val, onGenerate),
+      resetDetailPanels: () => store.actions.resetDetailPanels(),
     }
   },
 })

{fastapi_voyager-0.15.2.dist-info → fastapi_voyager-0.15.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-voyager
-Version: 0.15.2
+Version: 0.15.3
 Summary: Visualize FastAPI application's routing tree and dependencies
 Project-URL: Homepage, https://github.com/allmonday/fastapi-voyager
 Project-URL: Source, https://github.com/allmonday/fastapi-voyager

{fastapi_voyager-0.15.2.dist-info → fastapi_voyager-0.15.3.dist-info}/RECORD

@@ -9,7 +9,7 @@ fastapi_voyager/render_style.py,sha256=mPOuChEl71-3agCbPwkMt2sFmax2AEKDI6dK90eFP
 fastapi_voyager/server.py,sha256=MUc_ia3_QIbYQ8VenOxv3CEYVTiPDs7e_H40YoalxZs,8970
 fastapi_voyager/type.py,sha256=zluWvh5vpnjXJ9aAmyNJTSmXZPjAHCvgRT5oQRAjHrg,2104
 fastapi_voyager/type_helper.py,sha256=FmfrZAI3Z4uDdh3sH_kH7UGoY6yNVPapneSN86qY_wo,10209
-fastapi_voyager/version.py,sha256=MNw2WhSygJJXBlu1ZTOV_kDUGMOPYB98_73ZGP4k0S4,49
+fastapi_voyager/version.py,sha256=mV_h7Kelwuchi4ZvsHaY1gjoGeeu7EK0TqrMYIGLwgI,49
 fastapi_voyager/voyager.py,sha256=4vonmL-xt54C5San-DRBq4mjoV8Q96eoWRy68MJ1IJw,14169
 fastapi_voyager/templates/dot/cluster.j2,sha256=I2z9KkfCzmAtqXe0gXBnxnOfBXUSpdlATs3uf-O8_B8,307
 fastapi_voyager/templates/dot/cluster_container.j2,sha256=2tH1mOJvPoVKE_aHVMR3t06TfH_dYa9OeH6DBqSHt_A,204
@@ -30,8 +30,8 @@ fastapi_voyager/web/graphviz.svg.js,sha256=deI815RgxpZ3_MpELeV-TBYy2MVuUvZtQOHfS
 fastapi_voyager/web/index.html,sha256=lA59Op4u1bb-B105Iadn2KN_n11-AtXFdJglUezZIDg,23225
 fastapi_voyager/web/quasar.min.css,sha256=F5jQe7X2XT54VlvAaa2V3GsBFdVD-vxDZeaPLf6U9CU,203145
 fastapi_voyager/web/quasar.min.js,sha256=h0ftyPMW_CRiyzeVfQqiup0vrVt4_QWojpqmpnpn07E,502974
-fastapi_voyager/web/store.js,sha256=h9WLKgFdmHrF9riirX-3FnCODZzeNZcvnxqZvfFnXLw,2020
-fastapi_voyager/web/vue-main.js,sha256=49iJ_uoXde-jcYJpS-_Gd10zGuxo_nhp1-LAAsFzyVc,20034
+fastapi_voyager/web/store.js,sha256=zjmtx1HGN_umfyOQVwQgET-2V5hvXbS50YgXCr294Ok,14370
+fastapi_voyager/web/vue-main.js,sha256=1s11NOjILgjncJ4WbN1DGzTeLUb0a2-LYIA3lUIX8Bc,10564
 fastapi_voyager/web/component/demo.js,sha256=sAklFGhKGmMy9-ofgOw2oPIidAoIOgHu6yvV51L_MAA,350
 fastapi_voyager/web/component/render-graph.js,sha256=9wnO70n3eyPKTpa744idgs5PSwgvzbfv4InZ68eEOKs,2454
 fastapi_voyager/web/component/route-code-display.js,sha256=a823nBz3EEjutW2pfi73rcF3hodCBmgYNmuZi94sXE4,3615
@@ -43,8 +43,8 @@ fastapi_voyager/web/icon/favicon-16x16.png,sha256=JC07jEzfIYxBIoQn_FHXvyHuxESdhW
 fastapi_voyager/web/icon/favicon-32x32.png,sha256=C7v1h58cfWOsiLp9yOIZtlx-dLasBcq3NqpHVGRmpt4,1859
 fastapi_voyager/web/icon/favicon.ico,sha256=tZolYIXkkBcFiYl1A8ksaXN2VjGamzcSdes838dLvNc,15406
 fastapi_voyager/web/icon/site.webmanifest,sha256=GRozZ5suTykYcPMap1QhjrAB8PLW0mbT_phhzw_utvQ,316
-fastapi_voyager-0.15.2.dist-info/METADATA,sha256=O7X7HJ1JMuXk_bJJ93gre1ESQOaeyBxWj4UtYtku1jo,8513
-fastapi_voyager-0.15.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fastapi_voyager-0.15.2.dist-info/entry_points.txt,sha256=pEIKoUnIDXEtdMBq8EmXm70m16vELIu1VPz9-TBUFWM,53
-fastapi_voyager-0.15.2.dist-info/licenses/LICENSE,sha256=lNVRR3y_bFVoFKuK2JM8N4sFaj3m-7j29kvL3olFi5Y,1067
-fastapi_voyager-0.15.2.dist-info/RECORD,,
+fastapi_voyager-0.15.3.dist-info/METADATA,sha256=_NFcPd07mWHADnTH01kf6c2y0Lw9AQgqQNnHMK0Y5xE,8513
+fastapi_voyager-0.15.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fastapi_voyager-0.15.3.dist-info/entry_points.txt,sha256=pEIKoUnIDXEtdMBq8EmXm70m16vELIu1VPz9-TBUFWM,53
+fastapi_voyager-0.15.3.dist-info/licenses/LICENSE,sha256=lNVRR3y_bFVoFKuK2JM8N4sFaj3m-7j29kvL3olFi5Y,1067
+fastapi_voyager-0.15.3.dist-info/RECORD,,