tsondb 0.7.6 → 0.7.8

package/dist/src/node/server/index.js

@@ -21,6 +21,8 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../../../public")));
     app.use("/js/node_modules/preact", staticNodeModule("preact"));
+    app.use("/js/node_modules/@preact/signals", staticNodeModule("@preact/signals"));
+    app.use("/js/node_modules/@preact/signals-core", staticNodeModule("@preact/signals-core"));
     app.use("/js/node_modules/preact-iso", staticNodeModule("preact-iso"));
     app.use("/js/client", express.static(join(import.meta.dirname, "../../../../dist/src/web")));
     app.use("/js/shared", express.static(join(import.meta.dirname, "../../../../dist/src/shared")));
@@ -42,6 +44,8 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
             "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
             "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
             "preact-iso": "/js/node_modules/preact-iso/src/index.js",
+            "@preact/signals": "/js/node_modules/@preact/signals/dist/signals.module.js",
+            "@preact/signals-core": "/js/node_modules/@preact/signals-core/dist/signals-core.module.js",
         },
     }, null, 2);
     const customStylesheetLinkHeader = customStylesheetPath

package/dist/src/node/utils/instanceOperations.d.ts

@@ -2,7 +2,7 @@ import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
 import { type Result } from "../../shared/utils/result.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
 import { type ReferencesToInstances } from "./references.ts";
-export declare const createNewId: () => string;
+export declare const createNewId: () => `${string}-${string}-${string}-${string}-${string}`;
 export declare const checkCreateInstancePossible: (localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Result<string, [code: number, message: string]>;
 export declare const createInstance: (dataRoot: string, localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Promise<Result<string, [code: number, message: string]>>;
 export declare const checkUpdateInstancePossible: (instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown) => Result<void, [code: number, message: string]>;

package/dist/src/node/utils/instanceOperations.js

@@ -1,10 +1,10 @@
-import { v4 as uuidv4 } from "uuid";
+import { randomUUID } from "node:crypto";
 import { error, isOk, map, ok } from "../../shared/utils/result.js";
 import { createValidators, validateEntityDecl } from "../schema/index.js";
 import { getErrorMessageForDisplay } from "./error.js";
 import * as Files from "./files.js";
 import { isReferencedByOtherInstances } from "./references.js";
-export const createNewId = () => uuidv4();
+export const createNewId = () => randomUUID();
 export const checkCreateInstancePossible = (localeEntity, instancesByEntityName, entity, instanceContent, customId) => {
     const newInstanceId = entity === localeEntity ? customId : createNewId();
     if (typeof newInstanceId !== "string") {

package/dist/src/shared/api.d.ts

@@ -53,16 +53,32 @@ export interface GetAllInstancesResponseBody {
         }[];
     };
 }
+export interface IsRepoResponseBody {
+    isRepo: boolean;
+}
 export interface GitStatusResponseBody {
+    currentBranch: string | null;
+    trackingBranch: string | null;
     commitsAhead: number;
     commitsBehind: number;
     instances: {
         [entity: string]: InstanceContainerOverview[];
     };
 }
+export interface GetAllGitBranchesResponseBodyBranchSummary {
+    current: boolean;
+    name: string;
+    commit: string;
+    label: string;
+    linkedWorkTree: boolean;
+}
 export interface GetAllGitBranchesResponseBody {
-    allBranches: string[];
+    isDetached: boolean;
     currentBranch: string;
+    allBranches: string[];
+    branches: {
+        [key: string]: GetAllGitBranchesResponseBodyBranchSummary;
+    };
 }
 export interface CreateCommitRequestBody {
     message: string;

package/dist/src/shared/schema/declarations/EntityDecl.d.ts

@@ -27,6 +27,8 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TC
     isDeprecated?: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
+export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends (keyof T & string) | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
+export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
 export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
 export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;
 export {};

package/dist/src/shared/schema/declarations/EntityDecl.js

@@ -1,6 +1,8 @@
 import { NodeKind, resolveSerializedTypeArguments, } from "../Node.js";
 import { getReferencesForSerializedObjectType, } from "../types/ObjectType.js";
 export const isSerializedEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
+export const isSerializedEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
+export const isSerializedEntityDeclWithoutParentReference = (decl) => decl.parentReferenceKey === undefined;
 export const resolveTypeArgumentsInSerializedEntityDecl = (decls, _args, decl) => ({
     ...decl,
     type: resolveSerializedTypeArguments(decls, {}, decl.type),

package/dist/src/shared/schema/declarations/EnumDecl.d.ts

@@ -1,4 +1,4 @@
-import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.js";
 import type { SerializedTypeParameter } from "../TypeParameter.ts";
 import { type SerializedEnumCaseDecl, type SerializedEnumType } from "../types/EnumType.ts";
 import type { SerializedBaseDecl } from "./Declaration.ts";
@@ -7,5 +7,6 @@ export interface SerializedEnumDecl<Name extends string = string, T extends Reco
     type: SerializedEnumType<T>;
     isDeprecated?: boolean;
 }
+export declare const isSerializedEnumDecl: (node: SerializedNode) => node is SerializedEnumDecl;
 export declare const resolveTypeArgumentsInSerializedEnumDecl: SerializedTypeArgumentsResolver<SerializedEnumDecl>;
 export declare const getReferencesForSerializedEnumDecl: GetReferencesSerialized<SerializedEnumDecl>;

package/dist/src/shared/schema/declarations/EnumDecl.js

@@ -1,4 +1,6 @@
+import { NodeKind, } from "../Node.js";
 import { getReferencesForSerializedEnumType, resolveTypeArgumentsInSerializedEnumType, } from "../types/EnumType.js";
+export const isSerializedEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
 export const resolveTypeArgumentsInSerializedEnumDecl = (decls, args, decl) => {
     return {
         ...decl,

package/dist/src/shared/schema/declarations/TypeAliasDecl.d.ts

@@ -1,4 +1,4 @@
-import { type GetReferencesSerialized, type NodeKind, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
 import type { SerializedTypeParameter } from "../TypeParameter.ts";
 import type { SerializedType } from "../types/Type.ts";
 import type { SerializedBaseDecl } from "./Declaration.ts";
@@ -7,5 +7,6 @@ export interface SerializedTypeAliasDecl<Name extends string = string, T extends
     type: T;
     isDeprecated?: boolean;
 }
+export declare const isSerializedTypeAliasDecl: (node: SerializedNode) => node is SerializedTypeAliasDecl;
 export declare const resolveTypeArgumentsInSerializedTypeAliasDecl: SerializedTypeArgumentsResolver<SerializedTypeAliasDecl>;
 export declare const getReferencesForSerializedTypeAliasDecl: GetReferencesSerialized<SerializedTypeAliasDecl>;

package/dist/src/shared/schema/declarations/TypeAliasDecl.js

@@ -1,4 +1,5 @@
-import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
+import { getReferencesSerialized, NodeKind, resolveSerializedTypeArguments, } from "../Node.js";
+export const isSerializedTypeAliasDecl = (node) => node.kind === NodeKind.TypeAliasDecl;
 export const resolveTypeArgumentsInSerializedTypeAliasDecl = (decls, args, decl) => ({
     ...decl,
     parameters: [],

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

@@ -10,3 +10,7 @@ export type GitFileStatusForDisplay = "U" | "M" | "A" | "D" | "R" | undefined;
 export declare const hasFileChanges: (fileStatus: GitFileStatus | undefined) => boolean;
 export declare const getGitStatusForDisplay: (fileStatus: GitFileStatus | undefined) => GitFileStatusForDisplay;
 export declare const getLabelForGitStatus: (status: GitFileStatusForDisplay) => string;
+export declare const splitBranchName: (branch: string) => {
+    remote?: string;
+    name: string;
+};

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

@@ -87,7 +87,7 @@ export const getLabelForGitStatus = (status) => {
         case "M":
             return "modified";
         case "A":
-            return "sdded";
+            return "added";
         case "D":
             return "deleted";
         case "R":
@@ -96,3 +96,8 @@ export const getLabelForGitStatus = (status) => {
             return "";
     }
 };
+const remotePattern = /^remotes\/(\w+?)\/(.+)$/;
+export const splitBranchName = (branch) => {
+    const [_, remote, actualBranch] = branch.match(remotePattern) ?? ["", undefined, branch];
+    return { remote, name: actualBranch };
+};

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

@@ -2,50 +2,69 @@ type TextNode = {
     kind: "text";
     content: string;
 };
-export type InlineMarkdownNode = {
-    kind: "bold" | "italic";
+type BoldMarkdownNode = {
+    kind: "bold";
     content: InlineMarkdownNode[];
-} | {
+};
+type ItalicMarkdownNode = {
+    kind: "italic";
+    content: InlineMarkdownNode[];
+};
+type CodeMarkdownNode = {
     kind: "code";
     content: string;
-} | {
+};
+type LinkMarkdownNode = {
     kind: "link";
     href: string;
     content: InlineMarkdownNode[];
-} | {
+};
+type AttributedStringMarkdownNode = {
     kind: "attributed";
     attributes: Record<string, string | number | boolean>;
     content: InlineMarkdownNode[];
-} | TextNode;
-export type BlockMarkdownNode = {
+};
+export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode;
+type ParagraphBlockNode = {
     kind: "paragraph";
     content: InlineMarkdownNode[];
-} | {
+};
+type HeadingBlockNode = {
     kind: "heading";
     level: number;
     content: InlineMarkdownNode[];
-} | {
+};
+type ListBlockNode = {
     kind: "list";
     ordered: boolean;
-    content: {
-        kind: "listitem";
-        content: InlineMarkdownNode[];
-    }[];
-} | {
+    content: ListItemNode[];
+};
+type ListItemNode = {
+    kind: "listitem";
+    content: InlineMarkdownNode[];
+};
+type TableBlockNode = {
     kind: "table";
+    caption?: InlineMarkdownNode[];
     header: InlineMarkdownNode[][];
     rows: InlineMarkdownNode[][][];
 };
-export type BlockSyntaxMarkdownNode = InlineMarkdownNode | {
+export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode;
+type ListItemMarkerSyntaxNode = {
     kind: "listitemmarker";
     content: string;
-} | {
+};
+type TableMarkerSyntaxNode = {
     kind: "tablemarker";
     content: string;
-} | {
+};
+type HeadingMarkerSyntaxNode = {
     kind: "headingmarker";
     content: string;
 };
+type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode;
+export type BlockSyntaxMarkdownNode = InlineMarkdownNode | SyntaxNode;
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export declare const parseBlockMarkdownForSyntaxHighlighting: (text: string) => BlockSyntaxMarkdownNode[];
+export declare const reduceSyntaxNodes: <T extends BlockSyntaxMarkdownNode>(nodes: T[]) => T[];
 export {};

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[];
@@ -34,6 +35,11 @@ export type InstanceRouteSkeletonTitleBuilder = (values: {
 }) => string | undefined;
 type Props = {
     mode: "create" | "edit";
+    buttons: {
+        label: string;
+        name: string;
+        primary?: boolean;
+    }[];
     init: InstanceRouteSkeletonInitializer;
     titleBuilder: InstanceRouteSkeletonTitleBuilder;
     onSubmit: InstanceRouteSkeletonOnSubmitHandler;

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

@@ -1,21 +1,23 @@
 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";
-export const InstanceRouteSkeleton = ({ mode, init, titleBuilder, onSubmit, }) => {
+export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSubmit, }) => {
     const { params: { name, id }, } = useRoute();
     const [locales] = useSetting("displayedLocales");
     const [getDeclFromDeclName, declsLoaded] = useGetDeclFromDeclName();
@@ -24,6 +26,7 @@ export const InstanceRouteSkeleton = ({ mode, init, titleBuilder, onSubmit, }) =
     const [instanceContent, setInstanceContent] = useState();
     const [childInstances, setChildInstances] = useState([]);
     const [customId, setCustomId] = useState("");
+    const client = useContext(GitClientContext);
     const { route } = useLocation();
     useEffect(() => {
         document.title =
@@ -31,8 +34,8 @@ export const InstanceRouteSkeleton = ({ mode, init, titleBuilder, onSubmit, }) =
                 "Not found — TSONDB";
     }, [entity, id, instanceContent, locales, titleBuilder]);
     useEffect(() => {
-        if (entity && instanceContent === undefined) {
-            init({ locales, entity, instanceId: id, setInstanceContent, getDeclFromDeclName })
+        if (entity && instanceContent === undefined && declsLoaded) {
+            runWithLoading(() => init({ locales, entity, instanceId: id, setInstanceContent, getDeclFromDeclName }))
                 .then(() => id
                 ? getChildInstancesForInstanceByEntityName(locales, entity.name, id).then(result => {
                     setChildInstances(result.instances);
@@ -42,12 +45,12 @@ export const InstanceRouteSkeleton = ({ mode, init, titleBuilder, onSubmit, }) =
                 console.error("Error initializing instance route skeleton:", error);
             });
         }
-    }, [entity, getDeclFromDeclName, id, init, instanceContent, locales, name]);
+    }, [entity, declsLoaded, getDeclFromDeclName, id, init, instanceContent, locales, name]);
     const handleSubmit = (event) => {
         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, init, titleBuilder, onSubmit, }) =
                 setCustomId,
                 setInstanceContent,
                 childInstances,
-            }).catch((error) => {
+                updateLocalGitState: client?.updateLocalState,
+            })).catch((error) => {
                 console.error("Error submitting instance data:", error);
             });
         }
@@ -110,5 +114,5 @@ export const InstanceRouteSkeleton = ({ mode, init, titleBuilder, onSubmit, }) =
                             }
                         }, children: "Delete" }))] }), !id && isLocaleEntity && (_jsxs("div", { class: "field field--id", children: [_jsx("label", { htmlFor: "id", children: "ID" }), _jsx("p", { className: "comment", children: "The instance\u2019s identifier. An IETF language tag (BCP47)." }), _jsx("input", { type: "text", id: "id", value: customId, required: true, pattern: "[a-z]{2,3}(-[A-Z]{2,3})?", placeholder: "en-US, de-DE, \u2026", onInput: event => {
                             setCustomId(event.currentTarget.value);
-                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove }), _jsx("div", { class: "form-footer btns", children: _jsx("button", { type: "submit", name: "save", class: "primary", children: "Save" }) })] })] }));
+                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove }), _jsx("div", { class: "form-footer btns", children: buttons.map(button => (_jsx("button", { type: "submit", name: button.name, class: button.primary ? "primary" : undefined, children: button.label }, button.name))) })] })] }));
 };

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] }));
 };