tsondb 0.7.7 → 0.7.8

package/dist/src/shared/utils/markdown.js

@@ -1,3 +1,5 @@
+import { omitUndefinedKeys } from "./object.js";
+import { assertExhaustive } from "./typeSafety.js";
 const codeRule = {
     pattern: /`(.*?)`/,
     map: result => ({
@@ -122,13 +124,12 @@ const parsedAttributesLength = (rawAttributes) => rawAttributes.reduce((sum, att
         : attr.name.length + attr.separator.length + attr.rawValue.length), 0);
 const attributedRule = {
     pattern: /(?<!\\)\^\[(.*?[^\\])\]\(((?:\w+: *(?:true|false|\d+(?:\.\d+)?|"(.*?)(?<!\\)"|'(.*?)(?<!\\)'))(?:, *\w+: *(?:true|false|\d+(?:\.\d+)?|"(.*?)(?<!\\)"|'(.*?)(?<!\\)'))*)\)/,
-    map: (result, parseInside) => ({
+    map: ([_res, content = "", attributesText = ""], parseInside) => ({
         kind: "attributed",
-        attributes: mapAttributesToObject(parseAttributes(result[2] ?? "")),
-        content: parseInside(result[1] ?? ""),
+        attributes: mapAttributesToObject(parseAttributes(attributesText)),
+        content: parseInside(content),
     }),
-    mapHighlighting: (result, parseInside) => {
-        const attributesText = result[2] ?? "";
+    mapHighlighting: ([_res, content = "", attributesText = ""], parseInside) => {
         const attributes = parseAttributes(attributesText);
         const length = parsedAttributesLength(attributes);
         const unparsedText = attributesText.length > length
@@ -139,7 +140,7 @@ const attributedRule = {
             attributes: mapAttributesToObject(attributes),
             content: [
                 textNode("^["),
-                ...parseInside(result[1] ?? ""),
+                ...parseInside(content),
                 textNode("]("),
                 ...mapAttributesToNodes(attributes),
                 ...unparsedText,
@@ -154,7 +155,7 @@ const textNode = (content) => ({
 });
 const parseEscapedCharacters = (text) => text.replace(/\\([*_`[\]()\\])/g, "$1");
 const textRule = {
-    pattern: /.+/,
+    pattern: /.+/s,
     map: result => ({
         kind: "text",
         content: parseEscapedCharacters(result[0]),
@@ -225,13 +226,13 @@ const listRule = {
 };
 const paragraphRule = {
     pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(\n{2,}|\s*$)/,
-    map: result => ({
+    map: ([_res, content = "", _trailingWhitespace]) => ({
         kind: "paragraph",
-        content: parseInlineMarkdown(result[1] ?? "", false),
+        content: parseInlineMarkdown(content, false),
     }),
-    mapHighlighting: result => [
-        ...parseInlineMarkdown(result[1] ?? "", true),
-        ...nodesForTrailingWhitespace(result[2]),
+    mapHighlighting: ([_res, content = "", trailingWhitespace]) => [
+        ...parseInlineMarkdown(content, true),
+        ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
 const headingRule = {
@@ -253,26 +254,35 @@ const tableMarker = (text) => ({
     content: text,
 });
 const tableRule = {
-    pattern: /^(\| *)?(.+?(?: *(?<!\\)\| *.+?)+)( *\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|? *.+?(?: *(?<!\\)\| *.+?)* *(?<!\\)\|?)+)(\n{2,}|$)/,
-    map: result => ({
+    pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|.+?)*(?<!\\)\|?)+)(\n{2,}|$)/,
+    map: ([_res, _captionMarkerStart, caption, _captionMarkerEnd, _headerMarkerStart, headers, _headerMarkerEnd, _bodySeparators, body, _trailingWhitespace,]) => omitUndefinedKeys({
         kind: "table",
-        header: result[2]?.split("|").map(th => parseInlineMarkdown(th.trim(), false)) ?? [],
-        rows: result[5]
+        caption: caption !== undefined ? parseInlineMarkdown(caption.trim(), false) : undefined,
+        header: headers?.split("|").map(th => parseInlineMarkdown(th.trim(), false)) ?? [],
+        rows: body
             ?.split("\n")
             .slice(1)
             .map(tr => removeSurroundingPipes(tr)
             .split("|")
             .map(tc => parseInlineMarkdown(tc.trim(), false))) ?? [],
     }),
-    mapHighlighting: result => [
-        tableMarker(result[1] ?? ""),
-        ...(result[2]
+    mapHighlighting: ([_res, captionMarkerStart, caption, captionMarkerEnd, headerMarkerStart, headers, headerMarkerEnd, bodySeparators, body, trailingWhitespace,]) => [
+        ...(caption !== undefined
+            ? [
+                tableMarker(captionMarkerStart ?? ""),
+                ...parseInlineMarkdown(caption, true),
+                tableMarker(captionMarkerEnd ?? ""),
+                textNode("\n"),
+            ]
+            : []),
+        tableMarker(headerMarkerStart ?? ""),
+        ...(headers
             ?.split("|")
             .flatMap((th, i) => i === 0
             ? parseInlineMarkdown(th, true)
             : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
-        tableMarker((result[3] ?? "") + "\n" + (result[4] ?? "")),
-        ...(result[5]
+        tableMarker((headerMarkerEnd ?? "") + "\n" + (bodySeparators ?? "")),
+        ...(body
             ?.split("\n")
             .slice(1)
             .flatMap((tr) => [
@@ -283,7 +293,7 @@ const tableRule = {
                 ? parseInlineMarkdown(tc, true)
                 : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
         ]) ?? []),
-        ...nodesForTrailingWhitespace(result[6]),
+        ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
 const blockRules = [headingRule, tableRule, listRule, paragraphRule];
@@ -310,4 +320,50 @@ const parseForBlockRules = (rules, text, ruleParser, remainingRules = rules) =>
     }
 };
 export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text, parseActiveBlockRule);
-export const parseBlockMarkdownForSyntaxHighlighting = (text) => parseForBlockRules(blockRules, text, parseActiveBlockSyntaxRule);
+export const parseBlockMarkdownForSyntaxHighlighting = (text) => reduceSyntaxNodes(parseForBlockRules(blockRules, text, parseActiveBlockSyntaxRule));
+export const reduceSyntaxNodes = (nodes) => nodes.reduce((reducedNodes, node, index) => {
+    const lastNode = index > 0 ? reducedNodes[reducedNodes.length - 1] : undefined;
+    const newLastNode = lastNode ? mergeSyntaxNodes(lastNode, node) : null;
+    if (newLastNode) {
+        reducedNodes[reducedNodes.length - 1] = reduceSyntaxNode(newLastNode);
+    }
+    else {
+        reducedNodes.push(reduceSyntaxNode(node));
+    }
+    return reducedNodes;
+}, []);
+const reduceSyntaxNode = (node) => {
+    switch (node.kind) {
+        case "bold":
+        case "italic":
+            return { ...node, content: reduceSyntaxNodes(node.content) };
+        case "code":
+        case "link":
+        case "attributed":
+        case "text":
+        case "listitemmarker":
+        case "tablemarker":
+        case "headingmarker":
+            return node;
+        default:
+            return assertExhaustive(node);
+    }
+};
+const syntaxNodeMergeRules = {
+    bold: (a, b) => ({ ...a, content: [...a.content, ...b.content] }),
+    italic: (a, b) => ({ ...a, content: [...a.content, ...b.content] }),
+    code: (a, b) => ({ ...a, content: a.content + b.content }),
+    text: (a, b) => ({ ...a, content: a.content + b.content }),
+    listitemmarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    tablemarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    headingmarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    link: null,
+    attributed: null,
+};
+const mergeSyntaxNodes = (lastNode, node) => {
+    if (lastNode.kind !== node.kind) {
+        return null;
+    }
+    const mergeFn = syntaxNodeMergeRules[lastNode.kind];
+    return mergeFn?.(lastNode, node) ?? null;
+};

package/dist/src/shared/utils/object.d.ts

@@ -6,3 +6,4 @@ export type Leaves<T> = T extends object ? {
 }[keyof T] : never;
 export declare const onlyKeys: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Pick<T, K>;
 export declare const hasKey: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [k in K]: unknown; };
+export declare const omitUndefinedKeys: <T extends object>(obj: T) => T;

package/dist/src/shared/utils/object.js

@@ -10,3 +10,4 @@ export const mergeObjects = (obj1, obj2, solveConflict) => Object.entries(obj2).
 }), obj1);
 export const onlyKeys = (obj, ...keys) => Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
 export const hasKey = (obj, key) => Object.hasOwn(obj, key);
+export const omitUndefinedKeys = (obj) => Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));

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

@@ -1,14 +1,18 @@
-import type { GetAllGitBranchesResponseBody, GitStatusResponseBody } from "../../shared/api.ts";
+import type { GetAllGitBranchesResponseBody, GitStatusResponseBody, IsRepoResponseBody } from "../../shared/api.ts";
+export declare const isRepo: (locales: string[]) => Promise<IsRepoResponseBody>;
 export declare const getStatus: (locales: string[]) => Promise<GitStatusResponseBody>;
+export declare const fetch: (locales: string[]) => Promise<void>;
 export declare const stageAllFiles: (locales: string[]) => Promise<void>;
 export declare const stageAllFilesOfEntity: (locales: string[], entityName: string) => Promise<void>;
 export declare const stageFileOfEntity: (locales: string[], entityName: string, id: string) => Promise<void>;
 export declare const unstageAllFiles: (locales: string[]) => Promise<void>;
 export declare const unstageAllFilesOfEntity: (locales: string[], entityName: string) => Promise<void>;
 export declare const unstageFileOfEntity: (locales: string[], entityName: string, id: string) => Promise<void>;
+export declare const resetFileOfEntity: (locales: string[], entityName: string, id: string) => Promise<void>;
 export declare const commitStagedFiles: (locales: string[], message: string) => Promise<void>;
 export declare const pushCommits: (locales: string[]) => Promise<void>;
 export declare const pullCommits: (locales: string[]) => Promise<void>;
 export declare const getBranches: (locales: string[]) => Promise<GetAllGitBranchesResponseBody>;
 export declare const createBranch: (locales: string[], branchName: string) => Promise<void>;
 export declare const switchBranch: (locales: string[], branchName: string) => Promise<void>;
+export declare const deleteBranch: (locales: string[], branchName: string) => Promise<void>;

package/dist/src/web/api/git.js

@@ -1,11 +1,14 @@
-import { getResource, postResource } from "../utils/api.js";
+import { deleteResource, getResource, postResource } from "../utils/api.js";
+export const isRepo = async (locales) => getResource("/api/git", { locales });
 export const getStatus = async (locales) => getResource("/api/git/status", { locales });
+export const fetch = async (locales) => postResource("/api/git/fetch", { locales });
 export const stageAllFiles = async (locales) => postResource("/api/git/stage", { locales });
 export const stageAllFilesOfEntity = async (locales, entityName) => postResource(`/api/git/stage/${entityName}`, { locales });
 export const stageFileOfEntity = async (locales, entityName, id) => postResource(`/api/git/stage/${entityName}/${id}`, { locales });
 export const unstageAllFiles = async (locales) => postResource(`/api/git/unstage`, { locales });
 export const unstageAllFilesOfEntity = async (locales, entityName) => postResource(`/api/git/unstage/${entityName}`, { locales });
 export const unstageFileOfEntity = async (locales, entityName, id) => postResource(`/api/git/unstage/${entityName}/${id}`, { locales });
+export const resetFileOfEntity = async (locales, entityName, id) => postResource(`/api/git/reset/${entityName}/${id}`, { locales });
 export const commitStagedFiles = async (locales, message) => {
     const body = { message };
     return postResource(`/api/git/commit`, { locales, body });
@@ -17,4 +20,5 @@ export const createBranch = async (locales, branchName) => {
     const body = { branchName };
     return postResource(`/api/git/branch`, { locales, body });
 };
-export const switchBranch = async (locales, branchName) => postResource(`/api/git/branch/${branchName}`, { locales });
+export const switchBranch = async (locales, branchName) => postResource(`/api/git/branch/${encodeURIComponent(branchName)}`, { locales });
+export const deleteBranch = async (locales, branchName) => deleteResource(`/api/git/branch/${encodeURIComponent(branchName)}`, { locales });

package/dist/src/web/components/ContextProviderWrapper.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentChildren, Context } from "preact";
+export type ContextProviderWrapper = <T>(props: {
+    children?: ComponentChildren;
+    context: Context<T>;
+    useValue: () => T;
+}) => ComponentChildren;
+export declare const ContextProviderWrapper: ContextProviderWrapper;

package/dist/src/web/components/ContextProviderWrapper.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+export const ContextProviderWrapper = props => {
+    const { children, context, useValue } = props;
+    return _jsx(context.Provider, { value: useValue(), children: children });
+};

package/dist/src/web/components/InstanceRouteSkeleton.d.ts

@@ -25,6 +25,7 @@ export type InstanceRouteSkeletonOnSubmitHandler = (values: {
     setInstanceContent: Dispatch<SetStateAction<unknown>>;
     setCustomId: Dispatch<SetStateAction<string>>;
     getDeclFromDeclName: GetDeclFromDeclName;
+    updateLocalGitState?: () => Promise<void>;
 }) => Promise<void>;
 export type InstanceRouteSkeletonTitleBuilder = (values: {
     locales: string[];

package/dist/src/web/components/InstanceRouteSkeleton.js

@@ -1,17 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useLocation, useRoute } from "preact-iso";
-import { useCallback, useEffect, useState } from "preact/hooks";
+import { useCallback, useContext, useEffect, useState } from "preact/hooks";
 import { removeAt } from "../../shared/utils/array.js";
 import { getSerializedDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
 import { toTitleCase } from "../../shared/utils/string.js";
 import { validateLocaleIdentifier } from "../../shared/validation/identifier.js";
 import { deleteInstanceByEntityNameAndId, getChildInstancesForInstanceByEntityName, } from "../api/declarations.js";
+import { GitClientContext } from "../context/gitClient.js";
 import { useEntityFromRoute } from "../hooks/useEntityFromRoute.js";
 import { useInstanceNamesByEntity } from "../hooks/useInstanceNamesByEntity.js";
 import { useGetDeclFromDeclName, } from "../hooks/useSecondaryDeclarations.js";
 import { useSetting } from "../hooks/useSettings.js";
 import { homeTitle } from "../routes/Home.js";
 import { NotFound } from "../routes/NotFound.js";
+import { runWithLoading } from "../signals/loading.js";
 import { Layout } from "./Layout.js";
 import { TypeInput } from "./typeInputs/TypeInput.js";
 import { ValidationErrors } from "./typeInputs/utils/ValidationErrors.js";
@@ -24,6 +26,7 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
     const [instanceContent, setInstanceContent] = useState();
     const [childInstances, setChildInstances] = useState([]);
     const [customId, setCustomId] = useState("");
+    const client = useContext(GitClientContext);
     const { route } = useLocation();
     useEffect(() => {
         document.title =
@@ -32,7 +35,7 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
     }, [entity, id, instanceContent, locales, titleBuilder]);
     useEffect(() => {
         if (entity && instanceContent === undefined && declsLoaded) {
-            init({ locales, entity, instanceId: id, setInstanceContent, getDeclFromDeclName })
+            runWithLoading(() => init({ locales, entity, instanceId: id, setInstanceContent, getDeclFromDeclName }))
                 .then(() => id
                 ? getChildInstancesForInstanceByEntityName(locales, entity.name, id).then(result => {
                     setChildInstances(result.instances);
@@ -47,7 +50,7 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
         event.preventDefault();
         if (entity && instanceContent !== undefined) {
             const buttonName = event.submitter?.getAttribute("name") ?? undefined;
-            onSubmit({
+            runWithLoading(() => onSubmit({
                 locales,
                 entity,
                 instanceId: id,
@@ -60,7 +63,8 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
                 setCustomId,
                 setInstanceContent,
                 childInstances,
-            }).catch((error) => {
+                updateLocalGitState: client?.updateLocalState,
+            })).catch((error) => {
                 console.error("Error submitting instance data:", error);
             });
         }

package/dist/src/web/components/LoadingOverlay.d.ts

@@ -0,0 +1 @@
+export declare const LoadingOverlay: () => import("preact").JSX.Element;

package/dist/src/web/components/LoadingOverlay.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { loading } from "../signals/loading.js";
+export const LoadingOverlay = () => (_jsx("div", { class: "loading-overlay" + (loading.value ? " loading-overlay--open" : ""), "aria-hidden": !loading.value, children: "Loading\u2026" }));

package/dist/src/web/components/ModalDialog.js

@@ -1,6 +1,7 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useEffect, useRef } from "preact/hooks";
-export const ModalDialog = props => {
+import { LoadingOverlay } from "./LoadingOverlay.js";
+export const ModalDialog = ({ children, ...props }) => {
     const ref = useRef(null);
     useEffect(() => {
         if (ref.current) {
@@ -12,5 +13,5 @@ export const ModalDialog = props => {
             }
         }
     }, [props.open]);
-    return _jsx("dialog", { ...props, open: undefined, ref: ref });
+    return (_jsxs("dialog", { ...props, open: undefined, ref: ref, children: [_jsx(LoadingOverlay, {}), children] }));
 };

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/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;