bookish-press 0.4.1 → 0.4.3

package/components/page/ChapterNumber.svelte

@@ -0,0 +1,9 @@
+<span class="bookish-chapter-number"><slot /></span>
+
+<style>
+    .bookish-chapter-number {
+        font-family: var(--bookish-header-font-family);
+        font-weight: normal;
+        font-style: italic;
+    }
+</style>

package/components/page/ChapterNumber.svelte.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {typeof __propDef.props}  ChapterNumberProps */
+/** @typedef {typeof __propDef.events}  ChapterNumberEvents */
+/** @typedef {typeof __propDef.slots}  ChapterNumberSlots */
+export default class ChapterNumber extends SvelteComponentTyped<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}> {
+}
+export type ChapterNumberProps = typeof __propDef.props;
+export type ChapterNumberEvents = typeof __propDef.events;
+export type ChapterNumberSlots = typeof __propDef.slots;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: never;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export {};

package/components/page/ChapterTitle.svelte

@@ -0,0 +1,16 @@
+<script>import Link from '../Link.svelte';
+export let link = undefined;
+</script>
+
+{#if link}
+    <Link to={link}><h3> <slot /></h3></Link>
+{:else}
+    <h3><slot /></h3>
+{/if}
+
+<style>
+    h3 {
+        font-family: var(--bookish-header-font-family);
+        margin: 0;
+    }
+</style>

package/components/page/ChapterTitle.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        link?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type ChapterTitleProps = typeof __propDef.props;
+export type ChapterTitleEvents = typeof __propDef.events;
+export type ChapterTitleSlots = typeof __propDef.slots;
+export default class ChapterTitle extends SvelteComponentTyped<ChapterTitleProps, ChapterTitleEvents, ChapterTitleSlots> {
+}
+export {};

package/components/page/Contexts.d.ts

@@ -1,27 +1,47 @@
-import type { Writable } from "svelte/store";
-import type Book from "../../models/book/Book";
-import type Edition from "../../models/book/Edition";
-import type Authentication from "../Authentication";
-import type CaretContext from "../editor/CaretContext";
-import type ChapterContext from "./ChapterContext";
-export declare type AuthContext = Writable<Authentication>;
-export declare const AUTH: unique symbol;
-export declare function getAuth(): AuthContext;
-export declare type EditionStore = Writable<Edition>;
-export declare const EDITION: unique symbol;
-export declare function getEdition(): EditionStore;
-export declare type CaretStore = Writable<CaretContext>;
-export declare const CARET: unique symbol;
-export declare function getCaret(): CaretStore;
-export declare type DarkModeStore = Writable<boolean>;
+import { type Writable } from 'svelte/store';
+import type Book from '../../models/book/Book';
+import type Chapter from '../../models/book/Chapter';
+import type BookSaveStatus from '../../models/book/BookSaveStatus';
+import type Edition from '../../models/book/Edition';
+import type Authentication from '../Authentication';
+import type CaretState from '../editor/CaretState';
+import type ChapterContext from './ChapterContext';
+import type { DocumentReference } from 'firebase/firestore';
+export type DarkModeStore = Writable<boolean>;
 export declare const DARK_MODE: unique symbol;
 export declare function getDarkMode(): DarkModeStore;
-export declare type ChapterStore = Writable<ChapterContext>;
+export type UserStore = Writable<Authentication | undefined>;
+export declare const USER: unique symbol;
+export declare function getUser(): UserStore;
+export type BookStore = Writable<Book | undefined>;
+export declare const BOOK: unique symbol;
+export declare function getBook(): BookStore;
+export type EditionStore = Writable<Edition | undefined>;
+export declare const EDITION: unique symbol;
+export declare function getEdition(): EditionStore;
+export type ChapterText = [DocumentReference, string][];
+export type ChapterTextStore = Writable<ChapterText | undefined>;
+export declare const CHAPTERTEXT: unique symbol;
+export declare function getChapterText(): ChapterTextStore;
+export type ChapterStore = Writable<ChapterContext>;
 export declare const CHAPTER: unique symbol;
 export declare function getChapter(): ChapterStore;
-export declare const EDITABLE: unique symbol;
-export declare function isEditable(): unknown;
+/**
+ * Update the edition that contains the chapter, then update the
+ * global edition store with the new edition, propogating the changes everywhere.
+ */
+export declare function setChapter(store: EditionStore, previous: Chapter, chapter: Chapter): void;
+export declare function isChapterEditable(): boolean;
+export declare function isEditionEditable(): boolean;
+export declare function isEditionPartiallyEditable(): boolean;
+export declare function isBookEditable(): boolean;
 export declare const BASE: unique symbol;
-export declare function getBase(): string;
-export declare const BOOK: unique symbol;
-export declare function getBook(): Book;
+export type BaseStore = Writable<string>;
+export declare function getBase(): BaseStore;
+export declare const CARET: unique symbol;
+export declare function getCaret(): Writable<CaretState | undefined>;
+export declare const STATUS: unique symbol;
+export type StatusStore = Writable<BookSaveStatus>;
+export declare function getStatus(): StatusStore;
+export declare function lease(authStore: UserStore, editionStore: EditionStore, contentID: string, lock: boolean): Promise<boolean>;
+export declare function getLeasee(authStore: UserStore, editionStore: EditionStore, contentID: string): string | boolean;

package/components/page/Contexts.js

@@ -2,20 +2,132 @@
 // to avoid key collisions and prevent typos. This is partly
 // future-proofing, but also because getContext<Type>() isn't type safe,
 // as the resulting value is coerced to Type even if it's not that value.
-import { getContext } from "svelte";
-export const AUTH = Symbol("auth");
-export function getAuth() { return getContext(AUTH); }
-export const EDITION = Symbol("edition");
-export function getEdition() { return getContext(EDITION); }
-export const CARET = Symbol("caret");
-export function getCaret() { return getContext(CARET); }
-export const DARK_MODE = Symbol("dark");
-export function getDarkMode() { return getContext(DARK_MODE); }
-export const CHAPTER = Symbol("chapter");
-export function getChapter() { return getContext(CHAPTER); }
-export const EDITABLE = Symbol("editable");
-export function isEditable() { return getContext(EDITABLE); }
-export const BASE = Symbol("base");
-export function getBase() { return getContext(BASE); }
-export const BOOK = Symbol("book");
-export function getBook() { return getContext(BOOK); }
+import { getContext } from 'svelte';
+import { get } from 'svelte/store';
+import { page } from '$app/stores';
+import { updateLock } from '../../models/CRUD';
+export const DARK_MODE = Symbol('dark');
+export function getDarkMode() {
+    return getContext(DARK_MODE);
+}
+export const USER = Symbol('user');
+export function getUser() {
+    return getContext(USER);
+}
+export const BOOK = Symbol('book');
+export function getBook() {
+    return getContext(BOOK);
+}
+export const EDITION = Symbol('edition');
+export function getEdition() {
+    return getContext(EDITION);
+}
+export const CHAPTERTEXT = Symbol('chaptertext');
+export function getChapterText() {
+    return getContext(CHAPTERTEXT);
+}
+export const CHAPTER = Symbol('chapter');
+export function getChapter() {
+    return getContext(CHAPTER);
+}
+/**
+ * Update the edition that contains the chapter, then update the
+ * global edition store with the new edition, propogating the changes everywhere.
+ */
+export function setChapter(store, previous, chapter) {
+    const edition = get(store);
+    if (edition)
+        store.set(edition.withRevisedChapter(previous, chapter));
+}
+export function isChapterEditable() {
+    if (!get(page).route.id?.startsWith('/write'))
+        return false;
+    const auth = get(getUser());
+    const chapter = get(getChapter());
+    const edition = get(getEdition());
+    const book = get(getBook());
+    return (chapter !== undefined &&
+        edition !== undefined &&
+        book !== undefined &&
+        auth !== undefined &&
+        auth.user !== null &&
+        (chapter.chapter.isEditor(auth.user.uid) ||
+            edition.isEditor(auth.user.uid) ||
+            book.isEditor(auth.user.uid)));
+}
+export function isEditionEditable() {
+    if (!get(page).route.id?.startsWith('/write'))
+        return false;
+    const auth = get(getUser());
+    const edition = get(getEdition());
+    const book = get(getBook());
+    return (edition !== undefined &&
+        book !== undefined &&
+        auth !== undefined &&
+        auth.user !== null &&
+        (edition.isEditor(auth.user.uid) || book.isEditor(auth.user.uid)));
+}
+export function isEditionPartiallyEditable() {
+    if (!get(page).route.id?.startsWith('/write'))
+        return false;
+    const auth = get(getUser());
+    const edition = get(getEdition());
+    return (edition !== undefined &&
+        auth !== undefined &&
+        auth.user !== null &&
+        edition.isChapterEditor(auth.user.uid));
+}
+export function isBookEditable() {
+    if (!get(page).route.id?.startsWith('/write'))
+        return false;
+    const auth = get(getUser());
+    const book = get(getBook());
+    return (book !== undefined &&
+        auth !== undefined &&
+        auth.user !== null &&
+        book.isEditor(auth.user.uid));
+}
+export const BASE = Symbol('base');
+export function getBase() {
+    return getContext(BASE);
+}
+export const CARET = Symbol('caret');
+export function getCaret() {
+    return getContext(CARET);
+}
+export const STATUS = Symbol('status');
+export function getStatus() {
+    return getContext(STATUS);
+}
+export async function lease(authStore, editionStore, contentID, lock) {
+    const edition = get(editionStore);
+    const auth = get(authStore);
+    if (edition && auth && auth.user) {
+        await updateLock(edition, auth.user.uid, contentID, lock);
+        const latestEdition = get(editionStore);
+        const latestAuth = get(authStore);
+        if (latestEdition && latestAuth && latestAuth.user) {
+            editionStore.set(latestEdition.withLock(latestAuth.user.uid, contentID, lock));
+            return true;
+        }
+        else
+            return false;
+    }
+    else
+        return false;
+}
+export function getLeasee(authStore, editionStore, contentID) {
+    const edition = get(editionStore);
+    const auth = get(authStore);
+    if (edition !== undefined && auth !== undefined && auth.user !== null) {
+        const leasee = edition.getLeasee(contentID);
+        if (leasee === undefined)
+            return false;
+        else if (leasee === auth.user.uid)
+            return true;
+        else
+            return leasee;
+    }
+    else
+        return false;
+}

package/components/page/DefinitionView.svelte

@@ -5,17 +5,19 @@ import BookishEditor from '../editor/BookishEditor.svelte';
 import Format from '../chapter/Format.svelte';
 import Note from '../editor/Note.svelte';
 import { afterUpdate } from 'svelte';
-import { getEdition, isEditable } from './Contexts';
+import { getUser, getEdition, getLeasee, isChapterEditable, lease, } from './Contexts';
+import Button from '../app/Button.svelte';
 export let id;
 export let definition;
+let auth = getUser();
 let edition = getEdition();
-let editable = isEditable();
+let editable = isChapterEditable();
 // Focus after adding a new synonym.
 let newSynonym = false;
 let synonymsEditor = null;
 afterUpdate(() => {
     if (newSynonym && synonymsEditor) {
-        const editors = synonymsEditor.querySelectorAll("input");
+        const editors = synonymsEditor.querySelectorAll('input');
         if (editors.length > 0) {
             const last = editors[editors.length - 1];
             if (last instanceof HTMLElement)
@@ -24,106 +26,143 @@ afterUpdate(() => {
         newSynonym = false;
     }
 });
-$: format = Parser.parseFormat(undefined, definition.definition).withTextIfEmpty();
 function addSynonym() {
-    if ($edition && definition.synonyms) {
-        $edition.editDefinition(id, {
+    if ($edition) {
+        edition.set($edition.withEditedDefinition(id, {
             phrase: definition.phrase,
             definition: definition.definition,
-            synonyms: [...definition.synonyms, ""]
-        });
+            synonyms: [...(definition.synonyms ?? []), ''],
+        }));
     }
     newSynonym = true;
 }
 $: syns = definition.synonyms || [];
 </script>
 
-<tr>
-    <td>
-        {#if editable && edition }
-            <ConfirmButton
-                commandLabel="x"
-                confirmLabel="Confirm"
-                command={() => $edition.removeDefinition(id)}
-            />
-        {/if}
-        {#if editable && edition }
-            <strong>
+{#if $edition}
+    <section class="definition">
+        <dt>
+            {#if editable}
                 <TextEditor
-                    startText={definition.phrase} 
-                    label={'Glossary phrase editor.'} 
-                    placeholder="Phrase"
-                    valid={ text => {
-                        if(text.length === 0) return "Phrase can't be empty";
+                    text={definition.phrase}
+                    label={'Glossary phrase editor.'}
+                    placeholder="phrase"
+                    valid={(text) => {
+                        if (text.length === 0) return "phrase can't be empty";
                     }}
-                    save={text => $edition.editDefinition(id, { 
-                        phrase: text, 
-                        definition: definition.definition, 
-                        synonyms: definition.synonyms
-                    })}
+                    save={(text) =>
+                        $edition
+                            ? edition.set(
+                                  $edition.withEditedDefinition(id, {
+                                      phrase: text,
+                                      definition: definition.definition,
+                                      synonyms: definition.synonyms,
+                                  })
+                              )
+                            : undefined}
                 />
-            </strong>
-        {:else}
-            <strong>{#if definition.phrase }{definition.phrase}{:else}<em>Phrase</em>{/if}</strong>
-        {/if}
-    </td>
-    <td>
-        {#if editable && edition }
-            <BookishEditor
-                ast={format} 
-                save={node => $edition.editDefinition(id, { 
-                    phrase: definition.phrase, 
-                    definition: node.toBookdown(), 
-                    synonyms: definition.synonyms
-                })}
-                chapter={false}
-                component={Format}
-                placeholder="How would you define this?"
-            />
-        {:else}
-            {#if definition.definition === ""}
+            {:else if definition.phrase}{definition.phrase}{:else}<em
+                    >&mdash;</em
+                >{/if}
+            {#if editable}
+                <ConfirmButton
+                    tooltip="delete entry {definition.phrase}"
+                    commandLabel="- definition"
+                    confirmLabel="confirm"
+                    command={() =>
+                        $edition
+                            ? edition.set($edition.withoutDefinition(id))
+                            : undefined}
+                />
+            {/if}
+        </dt>
+
+        <dd class="term">
+            {#if editable && edition}
+                <BookishEditor
+                    text={definition.definition}
+                    parser={(text) =>
+                        Parser.parseFormat(undefined, text).withTextIfEmpty()}
+                    save={(node) =>
+                        $edition
+                            ? edition.set(
+                                  $edition.withEditedDefinition(id, {
+                                      phrase: definition.phrase,
+                                      definition: node.toBookdown(),
+                                      synonyms: definition.synonyms,
+                                  })
+                              )
+                            : undefined}
+                    chapter={false}
+                    component={Format}
+                    placeholder="definition"
+                    leasee={getLeasee(auth, edition, `definition-${id}`)}
+                    lease={(lock) =>
+                        lease(auth, edition, `definition-${id}`, lock)}
+                />
+            {:else if definition.definition === ''}
                 <em>Definition</em>
             {:else}
-                <Format node={format}/>
+                <Format
+                    node={Parser.parseFormat(
+                        undefined,
+                        definition.definition
+                    ).withTextIfEmpty()}
+                />
             {/if}
-        {/if}
-        <br/>
-        {#if edition && editable }
-            <span bind:this={synonymsEditor}>
-                <button on:click={addSynonym}>+</button>&nbsp;
-                {#if syns.length === 0 }
-                    <em>No synonyms</em>
-                {:else}
-                    {#each syns as syn, index }
-                        <Note>
-                            <TextEditor
-                                startText={syn} 
-                                label={'Synonym editor.'}
-                                placeholder="Synonym"
-                                valid={ () => undefined }
-                                save={text => {
-                                    const newSyns = [ ...syns ];
-                                    // Remove the synonym if it's empty but wasn't before
-                                    if(syn.length > 0 && text.length === 0)
-                                        newSyns.splice(index, 1);
-                                    else
-                                        newSyns[index] = text;
-                                    return $edition.editDefinition(id, { 
-                                        phrase: definition.phrase, 
-                                        definition: definition.definition, 
-                                        synonyms: newSyns
-                                    });
-                                }}
-                            />
-                        </Note>
-                        {#if syns.length > 1 && index < syns.length - 1 },&nbsp;{/if}
-                    {/each}
-                {/if}
-            </span>
-        {:else}
-            {#if definition.synonyms !== undefined && definition.synonyms.length > 0 }
-                <Note>{definition.synonyms.join(", ")}</Note>
+            {#if edition && editable}
+                <span bind:this={synonymsEditor}>
+                    {#if syns.length === 0}
+                        <Note>no synonyms</Note>
+                    {:else}
+                        {#each syns as syn, index}
+                            <Note>
+                                <TextEditor
+                                    text={syn}
+                                    label={'Synonym editor.'}
+                                    placeholder="synonym"
+                                    valid={() => undefined}
+                                    save={(text) => {
+                                        const newSyns = [...syns];
+                                        // Remove the synonym if it's empty but wasn't before
+                                        if (syn.length > 0 && text.length === 0)
+                                            newSyns.splice(index, 1);
+                                        else newSyns[index] = text;
+                                        if ($edition)
+                                            edition.set(
+                                                $edition.withEditedDefinition(
+                                                    id,
+                                                    {
+                                                        phrase: definition.phrase,
+                                                        definition:
+                                                            definition.definition,
+                                                        synonyms: newSyns,
+                                                    }
+                                                )
+                                            );
+                                    }}
+                                />
+                            </Note>
+                            {#if syns.length > 1 && index < syns.length - 1},&nbsp;{/if}
+                        {/each}
+                    {/if}
+                </span>&nbsp;<Button tooltip="add synonym" command={addSynonym}
+                    >+ synonym</Button
+                >
+            {:else if definition.synonyms !== undefined && definition.synonyms.length > 0}
+                <Note>{definition.synonyms.join(', ')}</Note>
             {/if}
-        {/if}
-    </td>
-</tr>
+        </dd>
+    </section>
+{/if}
+
+<style>
+    dd {
+        margin: 0;
+        margin-top: var(--bookish-paragraph-spacing);
+    }
+
+    dt {
+        font-weight: bold;
+    }
+</style>

package/components/page/DefinitionView.svelte.d.ts

@@ -10,9 +10,9 @@ declare const __propDef: {
     };
     slots: {};
 };
-export declare type DefinitionViewProps = typeof __propDef.props;
-export declare type DefinitionViewEvents = typeof __propDef.events;
-export declare type DefinitionViewSlots = typeof __propDef.slots;
+export type DefinitionViewProps = typeof __propDef.props;
+export type DefinitionViewEvents = typeof __propDef.events;
+export type DefinitionViewSlots = typeof __propDef.slots;
 export default class DefinitionView extends SvelteComponentTyped<DefinitionViewProps, DefinitionViewEvents, DefinitionViewSlots> {
 }
 export {};

package/components/page/Description.svelte

@@ -1,22 +1,34 @@
-<script>import Parser from "../../models/chapter/Parser";
-import ChapterBody from "../chapter/ChapterBody.svelte";
-import BookishEditor from "../editor/BookishEditor.svelte";
-import { getEdition, isEditable } from "./Contexts";
-let editable = isEditable();
+<script>import Parser from '../../models/chapter/Parser';
+import ChapterBody from '../chapter/ChapterBody.svelte';
+import BookishEditor from '../editor/BookishEditor.svelte';
+import { getUser, getEdition, getLeasee, isEditionEditable, lease, } from './Contexts';
+let auth = getUser();
+let editable = isEditionEditable();
 let edition = getEdition();
-$: descriptionNode = Parser.parseChapter($edition, $edition.getDescription());
 </script>
 
-<div class="bookish-description">
-    {#if editable}
-        <BookishEditor 
-            ast={descriptionNode} 
-            save={node => $edition.setDescription(node.toBookdown())}
-            chapter={false}
-            component={ChapterBody}
-            placeholder="What this book about?"
-        />
-    {:else}
-        <ChapterBody node={descriptionNode}/>
-    {/if}
-</div>
+{#if $edition}
+    <section class="bookish-description">
+        {#if editable}
+            <BookishEditor
+                text={$edition.getDescription()}
+                parser={(text) => Parser.parseChapter($edition, text)}
+                save={(node) =>
+                    $edition
+                        ? edition.set(
+                              $edition?.setDescription(node.toBookdown())
+                          )
+                        : undefined}
+                chapter={false}
+                component={ChapterBody}
+                placeholder="book description"
+                leasee={getLeasee(auth, edition, `description`)}
+                lease={(lock) => lease(auth, edition, `description`, lock)}
+            />
+        {:else}
+            <ChapterBody
+                node={Parser.parseChapter($edition, $edition.getDescription())}
+            />
+        {/if}
+    </section>
+{/if}

package/components/page/Description.svelte.d.ts

@@ -1,14 +1,14 @@
 import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
-    props: {};
+    props: Record<string, never>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export declare type DescriptionProps = typeof __propDef.props;
-export declare type DescriptionEvents = typeof __propDef.events;
-export declare type DescriptionSlots = typeof __propDef.slots;
+export type DescriptionProps = typeof __propDef.props;
+export type DescriptionEvents = typeof __propDef.events;
+export type DescriptionSlots = typeof __propDef.slots;
 export default class Description extends SvelteComponentTyped<DescriptionProps, DescriptionEvents, DescriptionSlots> {
 }
 export {};