@kernhq/module-quire 0.13.1 → 0.15.0

package/src/client/module.ts

@@ -49,6 +49,27 @@ export const quireClientModule = defineClientModule({
       component: () => import('./pages/SpacePage.svelte'),
       permission: QUIRE_PERMISSIONS.spaceView,
     },
+    /**
+     * Work on its way out and on its way in.
+     *
+     * Two literal segments, so it beats `/quire/:space` however the two are ordered — the shell
+     * scores a match as `literals * 1000 + segments`. Its place in this list is for a reader.
+     *
+     * **No `permission`, on purpose**, and this is the one route here without one. The screen has
+     * two halves behind two independent keys — `quire.page.export` is a member by default,
+     * `quire.page.import` is owner-and-admin — so a single gate would either hide it from somebody
+     * who may import or show it to somebody who may do neither; each half asks its own key instead.
+     * And a gate here would misbehave rather than 404: a route the shell refuses falls through to
+     * `/quire/:space`, which would tell the person "Space not found" about a space called
+     * *transfers*.
+     */
+    {
+      path: '/quire/transfers',
+      component: () => import('./pages/TransfersPage.svelte'),
+      get title() {
+        return t('transfers')
+      },
+    },
     /**
      * Declared before `/quire/:space/:page` for a reader's benefit only — the shell resolves by
      * specificity, not by order, so the two literal segments here beat the one in the page route
@@ -93,6 +114,21 @@ export const quireClientModule = defineClientModule({
       permission: QUIRE_PERMISSIONS.spaceManage,
       run: (ctx) => ctx.navigate('/quire?new=1'),
     },
+    /*
+     * The palette is the second way to a running job, and the one that works from anywhere.
+     * Gated on `page.export` rather than left open: the command list is a menu, and an entry that
+     * leads to a screen with both halves empty is an entry that teaches people to ignore the list.
+     * Somebody who may import and not export reaches the screen from the import dialog instead.
+     */
+    {
+      id: 'quire.transfers',
+      get label() {
+        return t('cmd_transfers')
+      },
+      icon: 'package',
+      permission: QUIRE_PERMISSIONS.pageExport,
+      run: (ctx) => ctx.navigate('/quire/transfers'),
+    },
   ],
 
   sidebar: [

package/src/client/pages/PageView.svelte

@@ -22,10 +22,12 @@ import { untrack } from 'svelte'
 import { getQuireApi } from '../api-instance.js'
 import CommentsPanel from '../components/CommentsPanel.svelte'
 import ConfirmDialog from '../components/ConfirmDialog.svelte'
+import ExportDialog from '../components/ExportDialog.svelte'
 import FavoriteStar from '../components/FavoriteStar.svelte'
 import PageEditor from '../components/PageEditor.svelte'
 import PageLabels from '../components/PageLabels.svelte'
 import PublishDialog from '../components/PublishDialog.svelte'
+import SaveAsTemplateDialog from '../components/SaveAsTemplateDialog.svelte'
 import VersionHistory from '../components/VersionHistory.svelte'
 import { type CoreApi, toPerson } from '../core-api.js'
 import DatabaseView from '../database/DatabaseView.svelte'
@@ -77,6 +79,19 @@ const membersQuery = createQuery(() => ({
   queryFn: () => core.workspaces.members.list({ workspaceId, limit: 200 }),
 }))
 
+/*
+ * The space by name, for the one sentence that needs it: "offered only in Handbook".
+ *
+ * The same query key the sidebar already holds, so this is a cache read rather than a request —
+ * and the key is what the URL carries, which is not a thing to show somebody in a sentence.
+ */
+const spacesQuery = createQuery(() => ({
+  queryKey: quireKeys.spaces(workspaceId),
+  enabled: Boolean(workspaceId),
+  queryFn: () => api.spaces.list({ workspaceId, includeArchived: false }),
+}))
+const spaceName = $derived((spacesQuery.data ?? []).find((space) => space.key === spaceKey)?.name ?? spaceKey)
+
 const query = createQuery(() => ({
   queryKey: quireKeys.page(workspaceId, pageId),
   enabled: Boolean(workspaceId && pageId),
@@ -266,6 +281,23 @@ async function revert() {
 let shareOpen = $state(false)
 const canPublish = $derived(canQuire('pagePublish'))
 
+/**
+ * Taking this page out as a file.
+ *
+ * Nothing is loaded for it here: the dialog is the only thing that knows what an export needs, and
+ * it asks for the space, the tree and any job already running the moment it opens. This screen's
+ * whole part in the feature is a flag and a menu entry, which is what an entry point should be.
+ */
+let exportOpen = $state(false)
+
+/**
+ * Saving this page as something to write with again.
+ *
+ * A flag and a menu entry, exactly like the export above: what a template needs to know is the
+ * dialog's business, and it reads the starters and the space list itself when it opens.
+ */
+let templateOpen = $state(false)
+
 const publicationsQuery = createQuery(() => ({
   queryKey: quireKeys.publications(workspaceId, doc?.spaceId ?? ''),
   enabled: canPublish && Boolean(workspaceId && doc?.spaceId),
@@ -592,6 +624,42 @@ async function undoTrash(workspace: string, id: string, spaceId: string, title:
                 },
               ]
             : []),
+          /*
+           * Every kind of page, not only a `page`. A live doc and a database both render through
+           * `renderPageDoc` like anything else — a database exports as the table it is — so the
+           * restriction that belongs on **Share to the web** does not belong here.
+           *
+           * `page.export` rather than `page.view`, matching what `exports.start` asks: reading a
+           * handbook a page at a time and walking out with the whole thing in a zip are different
+           * acts, and an administrator is allowed to think so.
+           */
+          ...(canQuire('pageExport')
+            ? [
+                {
+                  id: 'export',
+                  label: t('export_menu'),
+                  icon: 'download',
+                  onSelect: () => (exportOpen = true),
+                },
+              ]
+            : []),
+          /*
+           * `space.manage`, not `page.edit`, matching what `templates.createFromPage` asks — and the
+           * asymmetry is the point. A template changes what everybody in the space is offered the
+           * next time they make a page, which is the space's furniture rather than this page's
+           * content, exactly as a label is. Somebody who may write here is not thereby somebody who
+           * may add to everybody else's picker.
+           */
+          ...(canQuire('spaceManage')
+            ? [
+                {
+                  id: 'save-template',
+                  label: t('template_menu'),
+                  icon: 'clipboard-list',
+                  onSelect: () => (templateOpen = true),
+                },
+              ]
+            : []),
           {
             id: 'watch',
             label: watching ? t('watch_stop') : t('watch'),
@@ -757,6 +825,24 @@ async function undoTrash(workspace: string, id: string, spaceId: string, title:
 
   <PublishDialog bind:open={shareOpen} {workspaceId} spaceId={doc.spaceId} page={doc} />
 
+  <ExportDialog
+    bind:open={exportOpen}
+    {workspaceId}
+    spaceId={doc.spaceId}
+    page={{ id: doc.id, title: doc.title }}
+  />
+
+  {#if canQuire('spaceManage')}
+    <SaveAsTemplateDialog
+      bind:open={templateOpen}
+      {workspaceId}
+      spaceId={doc.spaceId}
+      {spaceName}
+      pageId={doc.id}
+      pageTitle={doc.title}
+    />
+  {/if}
+
   <!--
     The body says nothing about numbers until it knows them. Naming a count before the tree has
     loaded would be the same silent lie in a smaller size — "it goes to the trash" for a page that

package/src/client/pages/SpacePage.svelte

@@ -2,6 +2,7 @@
 import { Button, EmptyState, navigation, Skeleton, session } from '@kernhq/ui'
 import { createQuery } from '@tanstack/svelte-query'
 import { getQuireApi } from '../api-instance.js'
+import TemplatePicker from '../components/TemplatePicker.svelte'
 import { t } from '../i18n.js'
 import { canQuire } from '../permissions.js'
 import { quireKeys } from '../query.js'
@@ -57,6 +58,16 @@ const firstPageId = $derived(
 )
 
 let creating = $state(false)
+/**
+ * The first page of an empty space is the one page most worth offering a template for — a handbook
+ * that starts as a how-to is a handbook somebody kept writing. The picker still opens on **Blank
+ * page**, so nothing about starting from nothing got slower.
+ */
+let pickerOpen = $state(false)
+
+const open = (pageId: string) =>
+  void navigation.go(`/${workspaceSlug}/quire/${encodeURIComponent(spaceKey)}/${encodeURIComponent(pageId)}`)
+
 async function createFirst() {
   if (!space || creating) return
   creating = true
@@ -70,9 +81,7 @@ async function createFirst() {
       icon: null,
       afterId: null,
     })
-    void navigation.go(
-      `/${workspaceSlug}/quire/${encodeURIComponent(spaceKey)}/${encodeURIComponent(created.id)}`,
-    )
+    open(created.id)
   } finally {
     creating = false
   }
@@ -96,11 +105,18 @@ async function createFirst() {
     <EmptyState icon="file-text" title={t('space_empty')} description={t('space_empty_desc')}>
       {#snippet actions()}
         {#if canQuire('pageCreate')}
-          <Button disabled={creating} onclick={createFirst}>{t('new_page')}</Button>
+          <Button aria-busy={creating} onclick={() => (pickerOpen = true)}>{t('new_page')}</Button>
         {/if}
       {/snippet}
     </EmptyState>
   </div>
+  <TemplatePicker
+    bind:open={pickerOpen}
+    {workspaceId}
+    spaceId={space.id}
+    onBlank={() => void createFirst()}
+    onMade={(result) => result.pageId && open(result.pageId)}
+  />
 {/if}
 
 <style>