tsondb 0.7.6 → 0.7.8

package/dist/src/web/components/git/Git.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
+import { useContext, useState } from "preact/hooks";
+import { GitContext } from "../../context/git.js";
+import { GitClientContext } from "../../context/gitClient.js";
+import { ModalDialog } from "../ModalDialog.js";
+import { GitBranchManager } from "./GitBranchManager.js";
+import { GitFileManager } from "./GitFileManager.js";
+export const Git = () => {
+    const [isOpen, setIsOpen] = useContext(GitContext);
+    const [mode, setMode] = useState("files");
+    const client = useContext(GitClientContext);
+    if (!client || !client.isRepo) {
+        return null;
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(ModalDialog, { open: isOpen, class: "git", closedBy: "any", onClose: () => {
+                    setIsOpen(false);
+                }, children: [_jsxs("header", { children: [_jsx("h2", { children: (() => {
+                                    switch (mode) {
+                                        case "branches":
+                                            return "Branches";
+                                        case "files":
+                                            return "Files";
+                                        default:
+                                            return null;
+                                    }
+                                })() }), mode === "branches" ? (_jsx("button", { onClick: () => {
+                                    void client.fetch();
+                                }, children: "Fetch" })) : null, mode !== "files" ? (_jsx("button", { class: "git__tab git__tab--files", onClick: () => {
+                                    setMode("files");
+                                }, children: "View Files" })) : null, mode !== "branches" ? (_jsx("button", { class: "git__tab git__tab--branches", onClick: () => {
+                                    setMode("branches");
+                                }, children: "Manage Branches" })) : null, _jsx("button", { class: "close", onClick: () => {
+                                    setIsOpen(false);
+                                }, children: "Close" })] }), (() => {
+                        switch (mode) {
+                            case "branches":
+                                return _jsx(GitBranchManager, { client: client });
+                            case "files":
+                                return _jsx(GitFileManager, { client: client });
+                            default:
+                                return null;
+                        }
+                    })()] }), isOpen && mode === "files" ? null : (_jsxs("aside", { class: "git", children: [_jsx("h2", { class: "h1-faded", children: "Version Control" }), _jsx(GitFileManager, { client: client, manageBranches: () => {
+                            setIsOpen(true);
+                            setMode("branches");
+                        } })] }))] }));
+};

package/dist/src/web/components/git/GitBranchManager.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionComponent } from "preact";
+import type { GitClient } from "../../hooks/useGitClient.ts";
+type Props = {
+    client: GitClient;
+};
+export declare const GitBranchManager: FunctionComponent<Props>;
+export {};

package/dist/src/web/components/git/GitBranchManager.js

@@ -0,0 +1,17 @@
+import { jsxs as _jsxs, jsx as _jsx } from "preact/jsx-runtime";
+export const GitBranchManager = ({ client }) => {
+    return (_jsx("div", { class: "git-branches", children: _jsx("ul", { class: "branches", children: client.allBranches.map(branch => {
+                const branchInfo = client.branches[branch];
+                return (_jsxs("li", { class: [
+                        "form-row form-row--compact form-row--separated",
+                        branch === client.currentBranch ? "current" : undefined,
+                        branchInfo?.remote ? "remote" : undefined,
+                    ]
+                        .filter(className => className !== undefined)
+                        .join(" "), children: [_jsxs("span", { class: "branch__full-name form-row__fill form-row__text", title: branch, children: [branchInfo?.remote ? (_jsxs("span", { class: "branch__origin", children: [branchInfo.remote, "/"] })) : null, _jsx("span", { class: "branch__name", children: branchInfo?.name ?? branch })] }), _jsxs("div", { className: "form-row__group", children: [branch === client.currentBranch ? (_jsx("span", { class: "branch__current-indicator form-row__text", children: " (Current)" })) : null, _jsx("button", { onClick: () => {
+                                        void client.switchBranch(branch);
+                                    }, disabled: branch === client.currentBranch, children: "Switch" }), _jsx("button", { class: "destructive", onClick: () => {
+                                        void client.deleteBranch(branch);
+                                    }, disabled: branch === client.currentBranch || branch.startsWith("remotes/"), children: "Delete" })] })] }, branch));
+            }) }) }));
+};

package/dist/src/web/components/git/GitFileList.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentChildren } from "preact";
+import type { InstanceContainerOverview } from "../../../shared/utils/instances.ts";
+export type GitEntityOverview = [
+    entityName: string,
+    entityNamePlural: string,
+    instances: InstanceContainerOverview[]
+];
+type Props<A extends string> = {
+    filesByEntity: GitEntityOverview[];
+    fileButtons: {
+        label: string;
+        action: A;
+    }[];
+    onFileButtonClick: (entityName: string, instance: InstanceContainerOverview, action: A) => Promise<void>;
+};
+export declare const GitFileList: <A extends string>(props: Props<A>) => ComponentChildren;
+export {};

package/dist/src/web/components/git/GitFileList.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useLocation } from "preact-iso";
+import { GitStatusIndicator } from "./GitStatusIndicator.js";
+export const GitFileList = ({ filesByEntity, onFileButtonClick, fileButtons, }) => {
+    const { route } = useLocation();
+    return filesByEntity.length === 0 ? (_jsx("p", { class: "no-changes", children: "No changes" })) : (_jsx("ul", { class: "git-entity-list", children: filesByEntity.map(([entityName, entityNamePlural, instances]) => (_jsxs("li", { class: "git-entity-list-item", children: [_jsx("span", { class: "title", children: entityNamePlural }), _jsx("ul", { class: "git-instance-list", children: instances.map(instance => (_jsxs("li", { class: "form-row form-row--compact git-instance-list-item", children: [_jsx("span", { class: "title form-row__fill", children: instance.displayName }), _jsx(GitStatusIndicator, { status: instance.gitStatus }), _jsx("button", { onClick: () => {
+                                    route(`/entities/${entityName}/instances/${instance.id}`);
+                                }, children: "View" }), fileButtons.map(({ label, action }) => (_jsx("button", { onClick: () => {
+                                    void onFileButtonClick(entityName, instance, action);
+                                }, children: label }, label)))] }, instance.id))) })] }, entityName))) }));
+};

package/dist/src/web/components/git/GitFileManager.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionComponent } from "preact";
+import type { GitClient } from "../../hooks/useGitClient.ts";
+type Props = {
+    client: GitClient;
+    manageBranches?: () => void;
+};
+export declare const GitFileManager: FunctionComponent<Props>;
+export {};

package/dist/src/web/components/git/GitFileManager.js

@@ -0,0 +1,34 @@
+import { jsxs as _jsxs, jsx as _jsx } from "preact/jsx-runtime";
+import { useCallback, useState } from "preact/hooks";
+import { GitFileList } from "./GitFileList.js";
+export const GitFileManager = ({ client, manageBranches }) => {
+    const [commitMessage, setCommitMessage] = useState("");
+    const commit = () => {
+        void client.commit(commitMessage);
+    };
+    const onCreateBranch = () => {
+        const newBranchName = prompt("Enter new branch name:");
+        if (newBranchName !== null) {
+            void client.createBranch(newBranchName);
+        }
+    };
+    const onSwitchBranch = (event) => {
+        void client.switchBranch(event.currentTarget.value);
+    };
+    const onFileButtonClick = useCallback(async (entityName, instance, action) => {
+        switch (action) {
+            case "stage":
+                return client.stage(entityName, instance);
+            case "unstage":
+                return client.unstage(entityName, instance);
+            case "reset":
+                return client.reset(entityName, instance);
+        }
+    }, [client]);
+    return (_jsxs("div", { class: "git-files", children: [_jsxs("div", { class: "form-row form-row--sides", children: [_jsxs("div", { class: "form-row__group", children: [_jsxs("button", { onClick: () => void client.push(), children: ["Push", client.commitsAhead > 0 ? ` (${client.commitsAhead.toString()})` : ""] }), _jsxs("button", { onClick: () => void client.pull(), children: ["Pull", client.commitsBehind > 0 ? ` (${client.commitsBehind.toString()})` : ""] })] }), manageBranches ? _jsx("button", { onClick: manageBranches, children: "Manage Branches" }) : null] }), _jsxs("div", { class: "form-row", children: [_jsx("div", { class: "select-wrapper form-row__fill", children: _jsx("select", { value: client.currentBranch, onInput: onSwitchBranch, children: client.allBranches.map(branch => (_jsx("option", { value: branch, children: branch }, branch))) }) }), _jsx("button", { onClick: onCreateBranch, children: "New branch" })] }), _jsxs("div", { class: "form-row", children: [_jsx("input", { class: "form-row__fill", type: "text", value: commitMessage, onInput: event => {
+                            setCommitMessage(event.currentTarget.value);
+                        }, placeholder: "added X to instance Y, \u2026" }), _jsx("button", { onClick: commit, disabled: commitMessage.length === 0 || client.indexFiles.length === 0, children: "Commit" })] }), _jsxs("div", { class: "git-section-title", children: [_jsx("h3", { children: "Files to be committed" }), _jsx("button", { onClick: () => void client.unstageAll(), children: "Unstage all" })] }), _jsx(GitFileList, { filesByEntity: client.indexFiles, fileButtons: [{ label: "Unstage", action: "unstage" }], onFileButtonClick: onFileButtonClick }), _jsxs("div", { class: "git-section-title", children: [_jsx("h3", { children: "Working tree changes" }), _jsx("button", { onClick: () => void client.stageAll(), children: "Stage all" })] }), _jsx(GitFileList, { filesByEntity: client.workingTreeFiles, fileButtons: [
+                    { label: "Stage", action: "stage" },
+                    { label: "Reset", action: "reset" },
+                ], onFileButtonClick: onFileButtonClick })] }));
+};

package/dist/src/web/components/git/GitStatusIndicator.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionComponent } from "preact";
+import { type GitFileStatus } from "../../../shared/utils/git.ts";
+type Props = {
+    status: GitFileStatus | undefined;
+};
+export declare const GitStatusIndicator: FunctionComponent<Props>;
+export {};

package/dist/src/web/components/git/GitStatusIndicator.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { getGitStatusForDisplay, getLabelForGitStatus, } from "../../../shared/utils/git.js";
+export const GitStatusIndicator = ({ status }) => {
+    const gitStatusForDisplay = getGitStatusForDisplay(status);
+    return (_jsx("span", { class: `git-status git-status--${gitStatusForDisplay ?? ""}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay }));
+};

package/dist/src/web/components/typeInputs/StringTypeInput.js

@@ -12,7 +12,7 @@ export const StringTypeInput = ({ type, value, disabled, onChange }) => {
     const errors = validateStringConstraints(type, value);
     return (_jsx("div", { class: "field field--string", children: isMarkdown ? (_jsxs(_Fragment, { children: [_jsxs("div", { class: "editor editor--markdown", children: [_jsxs("div", { class: "textarea-grow-wrap", children: [_jsx("textarea", { value: value, minLength: minLength, maxLength: maxLength, onInput: event => {
                                         onChange(event.currentTarget.value);
-                                    }, "aria-invalid": errors.length > 0, disabled: disabled }), _jsxs("p", { class: "help", children: ["This textarea supports", " ", _jsx("a", { href: "https://www.markdownguide.org/getting-started/", target: "_blank", rel: "noreferrer", children: "Markdown" }), "."] }), _jsx(MarkdownHighlighting, { class: "textarea-grow-wrap__mirror editor-highlighting", string: value })] }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }), _jsx("div", { class: "preview", children: _jsx(Markdown, { string: value, outerHeadingLevel: 2 }) })] })) : (_jsxs("div", { class: "editor", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern === undefined
+                                    }, "aria-invalid": errors.length > 0, disabled: disabled }), _jsxs("p", { class: "help", children: ["This textarea supports", " ", _jsx("a", { href: "https://www.markdownguide.org/getting-started/", target: "_blank", rel: "noreferrer", children: "Markdown" }), "."] }), _jsx(MarkdownHighlighting, { class: "textarea-grow-wrap__mirror editor-highlighting", string: value + " " })] }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }), _jsx("div", { class: "preview", children: _jsx(Markdown, { string: value, outerHeadingLevel: 2 }) })] })) : (_jsxs("div", { class: "editor", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern === undefined
                         ? undefined
                         : pattern.startsWith("^(?:") && pattern.endsWith(")$")
                             ? pattern.slice(4, -2)

package/dist/src/web/components/typeInputs/utils/MismatchingTypeError.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 export const MismatchingTypeError = ({ expected, actual }) => {
-    return (_jsxs("div", { role: "alert", children: ["Expected value of type ", expected, ", but got ", JSON.stringify(actual)] }));
+    return (_jsxs("div", { role: "alert", children: ["Expected value of type ", expected, ", but got", " ", _jsx("code", { children: actual === undefined ? "undefined" : JSON.stringify(actual) })] }));
 };

package/dist/src/web/context/entities.d.ts

@@ -1,9 +1,10 @@
 import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
+export type EntitySummary = {
+    declaration: SerializedEntityDecl;
+    instanceCount: number;
+    isLocaleEntity: boolean;
+};
 export declare const EntitiesContext: import("preact").Context<{
-    entities: {
-        declaration: SerializedEntityDecl;
-        instanceCount: number;
-        isLocaleEntity: boolean;
-    }[];
+    entities: EntitySummary[];
     reloadEntities: () => Promise<void>;
 }>;

package/dist/src/web/context/git.d.ts

@@ -1,3 +1,4 @@
 import type { SetStateAction } from "preact/compat";
 import type { Dispatch } from "preact/hooks";
-export declare const GitContext: import("preact").Context<[isOpen: boolean, setIsOpen: Dispatch<SetStateAction<boolean>>]>;
+export type GitContext = [isOpen: boolean, setIsOpen: Dispatch<SetStateAction<boolean>>];
+export declare const GitContext: import("preact").Context<GitContext>;

package/dist/src/web/context/gitClient.d.ts

@@ -0,0 +1,2 @@
+import type { GitClient } from "../hooks/useGitClient.ts";
+export declare const GitClientContext: import("preact").Context<GitClient | undefined>;

package/dist/src/web/context/gitClient.js

@@ -0,0 +1,2 @@
+import { createContext } from "preact";
+export const GitClientContext = createContext(undefined);

package/dist/src/web/hooks/useGitClient.d.ts

@@ -0,0 +1,37 @@
+import { type GitFileStatus } from "../../shared/utils/git.ts";
+import type { InstanceContainerOverview } from "../../shared/utils/instances.ts";
+import type { GitEntityOverview } from "../components/git/GitFileList.tsx";
+export type GitBranchSummary = {
+    current: boolean;
+    name: string;
+    commit: string;
+    label: string;
+    linkedWorkTree: boolean;
+    remote?: string;
+};
+export type GitClient = {
+    isRepo: boolean;
+    commitsAhead: number;
+    commitsBehind: number;
+    indexFiles: GitEntityOverview[];
+    workingTreeFiles: GitEntityOverview[];
+    allBranches: string[];
+    currentBranch: string;
+    branches: Record<string, GitBranchSummary>;
+    isDetached: boolean;
+    updateLocalState: () => Promise<void>;
+    getGitStatusOfInstance: (entityName: string, instanceId: string) => GitFileStatus | undefined;
+    fetch: () => Promise<void>;
+    stage: (entityName: string, instance: InstanceContainerOverview) => Promise<void>;
+    stageAll: (entityName?: string) => Promise<void>;
+    unstage: (entityName: string, instance: InstanceContainerOverview) => Promise<void>;
+    unstageAll: (entityName?: string) => Promise<void>;
+    reset: (entityName: string, instance: InstanceContainerOverview) => Promise<void>;
+    commit: (commitMessage: string) => Promise<void>;
+    push: () => Promise<void>;
+    pull: () => Promise<void>;
+    createBranch: (newBranchName: string) => Promise<void>;
+    switchBranch: (targetBranch: string) => Promise<void>;
+    deleteBranch: (targetBranch: string) => Promise<void>;
+};
+export declare const useGitClient: () => GitClient;

package/dist/src/web/hooks/useGitClient.js

@@ -0,0 +1,313 @@
+import { useCallback, useContext, useEffect, useMemo, useState } from "preact/hooks";
+import { isSerializedEntityDecl, isSerializedEntityDeclWithParentReference, } from "../../shared/schema/declarations/EntityDecl.js";
+import { isChangedInIndex, isChangedInWorkingDir, splitBranchName, } from "../../shared/utils/git.js";
+import { deleteInstanceByEntityNameAndId } from "../api/declarations.js";
+import * as GitApi from "../api/git.js";
+import { EntitiesContext } from "../context/entities.js";
+import { runWithLoading } from "../signals/loading.js";
+import { logAndAlertError } from "../utils/debug.js";
+import { useSetting } from "./useSettings.js";
+const filterFilesForDisplay = (predicate, entities, data) => Object.entries(data.instances)
+    .map(([entityName, instances]) => [
+    entityName,
+    entities.find(entity => entity.declaration.name === entityName)?.declaration.namePlural ??
+        entityName,
+    instances
+        .filter(instance => instance.gitStatus !== undefined && predicate(instance.gitStatus))
+        .sort((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })),
+])
+    .filter(([_1, _2, instances]) => instances.length > 0)
+    .sort((a, b) => a[1].localeCompare(b[1]));
+export const useGitClient = () => {
+    const [locales] = useSetting("displayedLocales");
+    const { entities } = useContext(EntitiesContext);
+    const [isRepo, setIsRepo] = useState(false);
+    const [commitsAhead, setCommitsAhead] = useState(0);
+    const [commitsBehind, setCommitsBehind] = useState(0);
+    const [indexFiles, setIndexFiles] = useState([]);
+    const [workingTreeFiles, setWorkingTreeFiles] = useState([]);
+    const [allBranches, setAllBranches] = useState([]);
+    const [currentBranch, setCurrentBranch] = useState("");
+    const [branches, setBranches] = useState({});
+    const [isDetached, setIsDetached] = useState(false);
+    const updateGitStatus = useCallback(async () => {
+        const { isRepo } = await GitApi.isRepo(locales);
+        setIsRepo(isRepo);
+        if (isRepo && entities.length > 0) {
+            try {
+                const [statusData, branchesData] = await Promise.all([
+                    GitApi.getStatus(locales),
+                    GitApi.getBranches(locales),
+                ]);
+                setIndexFiles(filterFilesForDisplay(isChangedInIndex, entities, statusData));
+                setWorkingTreeFiles(filterFilesForDisplay(isChangedInWorkingDir, entities, statusData));
+                setCommitsAhead(statusData.commitsAhead);
+                setCommitsBehind(statusData.commitsBehind);
+                setAllBranches(branchesData.allBranches);
+                setCurrentBranch(branchesData.currentBranch);
+                setBranches(Object.fromEntries(Object.entries(branchesData.branches).map(([branch, branchSummary]) => {
+                    const { remote, name } = splitBranchName(branch);
+                    return [
+                        branch,
+                        {
+                            ...branchSummary,
+                            remote,
+                            name,
+                        },
+                    ];
+                })));
+                setIsDetached(branchesData.isDetached);
+            }
+            catch (error) {
+                logAndAlertError(error, "Error updating git status: ");
+            }
+        }
+    }, [entities, locales]);
+    useEffect(() => {
+        void updateGitStatus();
+    }, [updateGitStatus]);
+    const getGitStatusOfInstance = useCallback((entityName, instanceId) => {
+        const entity = indexFiles.find(([name]) => name === entityName);
+        const instanceInIndex = entity?.[2].find(instance => instance.id === instanceId);
+        if (instanceInIndex?.gitStatus !== undefined) {
+            return instanceInIndex.gitStatus;
+        }
+        const workingTreeEntity = workingTreeFiles.find(([name]) => name === entityName);
+        const instanceInWorkingTree = workingTreeEntity?.[2].find(instance => instance.id === instanceId);
+        return instanceInWorkingTree?.gitStatus;
+    }, [indexFiles, workingTreeFiles]);
+    const fetch = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.fetch(locales);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error fetching from remote: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const stage = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.stageFileOfEntity(locales, entityName, instance.id);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error staging instance: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const stageAll = useCallback(async (entityName) => {
+        await runWithLoading(async () => {
+            try {
+                if (entityName) {
+                    await GitApi.stageAllFilesOfEntity(locales, entityName);
+                }
+                else {
+                    await GitApi.stageAllFiles(locales);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error staging all instances: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const unstage = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.unstageFileOfEntity(locales, entityName, instance.id);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error unstaging instance: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const unstageAll = useCallback(async (entityName) => {
+        await runWithLoading(async () => {
+            try {
+                if (entityName) {
+                    await GitApi.unstageAllFilesOfEntity(locales, entityName);
+                }
+                else {
+                    await GitApi.unstageAllFiles(locales);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error unstaging all instances: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const reset = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            if (!confirm(`Are you sure you want to reset instance "${instance.displayName}" (${instance.id})?`)) {
+                return;
+            }
+            const entity = entities.find(e => e.declaration.name === entityName)?.declaration;
+            if (instance.gitStatus?.workingDir === "D" &&
+                entity &&
+                isSerializedEntityDecl(entity) &&
+                isSerializedEntityDeclWithParentReference(entity) &&
+                !confirm(`If you deleted the parent of "${instance.displayName}" (${instance.id}) before, make sure to restore it as well. Continue?`)) {
+                return;
+            }
+            try {
+                if (instance.gitStatus?.workingDir === "?") {
+                    await deleteInstanceByEntityNameAndId(locales, entityName, instance.id);
+                }
+                else {
+                    await GitApi.resetFileOfEntity(locales, entityName, instance.id);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error resetting instance: ");
+            }
+        });
+    }, [entities, locales, updateGitStatus]);
+    const commit = useCallback(async (commitMessage) => {
+        await runWithLoading(async () => {
+            if (commitMessage.length > 0 &&
+                indexFiles.length > 0 &&
+                confirm("Do you want to commit all staged files?")) {
+                try {
+                    await GitApi.commitStagedFiles(locales, commitMessage);
+                    await updateGitStatus();
+                }
+                catch (error) {
+                    logAndAlertError(error, "Error committing instances: ");
+                }
+            }
+        });
+    }, [indexFiles.length, locales, updateGitStatus]);
+    const push = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.pushCommits(locales);
+                alert("Pushed commits successfully");
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error pushing commits: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const pull = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.pullCommits(locales);
+                alert("Pulled commits successfully");
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error pulling commits: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const createBranch = useCallback(async (newBranchName) => {
+        await runWithLoading(async () => {
+            if (newBranchName.length === 0) {
+                alert("Branch name cannot be empty");
+                return;
+            }
+            if (allBranches.includes(newBranchName)) {
+                alert("Branch name already exists");
+                return;
+            }
+            try {
+                await GitApi.createBranch(locales, newBranchName);
+                alert(`Created branch "${newBranchName}" successfully`);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error creating branch: ");
+            }
+        });
+    }, [allBranches, locales, updateGitStatus]);
+    const switchBranch = useCallback(async (targetBranch) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.switchBranch(locales, targetBranch);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error switching branch: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const deleteBranch = useCallback(async (targetBranch) => {
+        await runWithLoading(async () => {
+            if (targetBranch === currentBranch) {
+                alert("Cannot delete the current branch");
+                return;
+            }
+            if (!allBranches.includes(targetBranch)) {
+                alert(`Branch "${targetBranch}" does not exist`);
+                return;
+            }
+            if (!confirm(`Are you sure you want to delete branch "${targetBranch}"?`)) {
+                return;
+            }
+            try {
+                await GitApi.deleteBranch(locales, targetBranch);
+                alert(`Deleted branch "${targetBranch}" successfully`);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error deleting branch: ");
+            }
+        });
+    }, [allBranches, currentBranch, locales, updateGitStatus]);
+    return useMemo(() => ({
+        isRepo,
+        commitsAhead,
+        commitsBehind,
+        indexFiles,
+        workingTreeFiles,
+        allBranches,
+        currentBranch,
+        branches,
+        isDetached,
+        getGitStatusOfInstance,
+        updateLocalState: updateGitStatus,
+        fetch,
+        stage,
+        stageAll,
+        unstage,
+        unstageAll,
+        reset,
+        commit,
+        push,
+        pull,
+        createBranch,
+        switchBranch,
+        deleteBranch,
+    }), [
+        allBranches,
+        branches,
+        commit,
+        commitsAhead,
+        commitsBehind,
+        createBranch,
+        currentBranch,
+        deleteBranch,
+        fetch,
+        getGitStatusOfInstance,
+        indexFiles,
+        isDetached,
+        isRepo,
+        pull,
+        push,
+        reset,
+        stage,
+        stageAll,
+        switchBranch,
+        unstage,
+        unstageAll,
+        updateGitStatus,
+        workingTreeFiles,
+    ]);
+};

package/dist/src/web/hooks/useSecondaryDeclarations.js

@@ -1,4 +1,7 @@
 import { useCallback, useEffect, useState } from "preact/hooks";
+import { isSerializedEntityDeclWithParentReference } from "../../shared/schema/declarations/EntityDecl.js";
+import { isSerializedEnumDecl } from "../../shared/schema/declarations/EnumDecl.js";
+import { isSerializedTypeAliasDecl } from "../../shared/schema/declarations/TypeAliasDecl.js";
 import { getAllDeclarations } from "../api/declarations.js";
 import { useSetting } from "./useSettings.js";
 export const useGetDeclFromDeclName = () => {
@@ -9,9 +12,9 @@ export const useGetDeclFromDeclName = () => {
             .then(data => {
             setSecondaryDeclarations(data.declarations
                 .map(decl => decl.declaration)
-                .filter((decl) => decl.kind === "EnumDecl" ||
-                decl.kind === "TypeAliasDecl" ||
-                decl.parentReferenceKey !== undefined));
+                .filter(decl => isSerializedEnumDecl(decl) ||
+                isSerializedTypeAliasDecl(decl) ||
+                isSerializedEntityDeclWithParentReference(decl)));
         })
             .catch((error) => {
             if (error instanceof Error) {

package/dist/src/web/hooks/useSettings.js

@@ -9,7 +9,6 @@ const defaultSettingsFromConfig = (config) => ({
     displayedLocales: config.defaultLocales.length > 0 ? config.defaultLocales : defaultSettings.displayedLocales,
 });
 export const useSettings = (config) => {
-    console.log("useSettings");
     const [settings, setSettings] = useState(() => Object.fromEntries(Object.entries(defaultSettingsFromConfig(config)).map(([key, initialValue]) => {
         const item = localStorage.getItem(key);
         if (item) {

package/dist/src/web/index.js

@@ -4,11 +4,15 @@ import { LocationProvider, Route, Router, useLocation } from "preact-iso";
 import { useEffect, useState } from "preact/hooks";
 import { getAllEntities } from "./api/declarations.js";
 import { getWebConfig } from "./api/index.js";
-import { Git } from "./components/Git.js";
+import { ContextProviderWrapper } from "./components/ContextProviderWrapper.js";
+import { Git } from "./components/git/Git.js";
+import { LoadingOverlay } from "./components/LoadingOverlay.js";
 import { ConfigContext } from "./context/config.js";
 import { EntitiesContext } from "./context/entities.js";
 import { GitContext } from "./context/git.js";
+import { GitClientContext } from "./context/gitClient.js";
 import { SettingsContext } from "./context/settings.js";
+import { useGitClient } from "./hooks/useGitClient.js";
 import { useMappedAPIResource } from "./hooks/useMappedAPIResource.js";
 import { useSettings } from "./hooks/useSettings.js";
 import { CreateInstance } from "./routes/CreateInstance.js";
@@ -29,7 +33,7 @@ const App = ({ config }) => {
             alert("Error reloading entities: " + String(error));
         });
     }, [location.path, reloadEntities]);
-    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsxs(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: [_jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }));
+    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsx(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: _jsxs(ContextProviderWrapper, { context: GitClientContext, useValue: useGitClient, children: [_jsx(LoadingOverlay, {}), _jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }) }));
 };
 const config = await getWebConfig();
 const root = document.getElementById("app");