tsondb 0.5.19 → 0.6.1

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

@@ -29,3 +29,33 @@ export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
     return acc;
 }, { removed: oldArr, added: newArr });
 export const unique = (arr, equalityCheck = (a, b) => a === b) => arr.filter((item, index) => arr.findIndex(other => equalityCheck(item, other)) === index);
+/**
+ * Moves an element from one position to another within the array.
+ */
+export const reorder = (arr, sourceIndex, targetIndex) => {
+    if (sourceIndex < 0 || sourceIndex >= arr.length) {
+        throw new RangeError(`source index ${sourceIndex.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    if (targetIndex < 0 || targetIndex >= arr.length) {
+        throw new RangeError(`target index ${targetIndex.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    if (sourceIndex === targetIndex) {
+        return arr;
+    }
+    if (sourceIndex < targetIndex) {
+        return [
+            ...arr.slice(0, sourceIndex),
+            ...arr.slice(sourceIndex + 1, targetIndex + 1),
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            arr[sourceIndex],
+            ...arr.slice(targetIndex + 1),
+        ];
+    }
+    return [
+        ...arr.slice(0, targetIndex),
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        arr[sourceIndex],
+        ...arr.slice(targetIndex, sourceIndex),
+        ...arr.slice(sourceIndex + 1),
+    ];
+};

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

@@ -0,0 +1,8 @@
+/**
+ * A simple async map to process tasks with a concurrency limit.
+ * @param tasks The list of tasks to process.
+ * @param worker The async function to process each task.
+ * @param concurrency The maximum number of concurrent tasks.
+ * @returns A promise that resolves to the list of results.
+ */
+export declare const mapAsync: <T, R>(tasks: readonly T[], worker: (task: T) => Promise<R>, concurrency: number) => Promise<R[]>;

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

@@ -0,0 +1,35 @@
+/**
+ * A simple async map to process tasks with a concurrency limit.
+ * @param tasks The list of tasks to process.
+ * @param worker The async function to process each task.
+ * @param concurrency The maximum number of concurrent tasks.
+ * @returns A promise that resolves to the list of results.
+ */
+export const mapAsync = (tasks, worker, concurrency) => new Promise((resolve, reject) => {
+    const results = [];
+    let activeIndex = 0;
+    let activeCount = 0;
+    let resolvedCount = 0;
+    const totalCount = tasks.length;
+    const runNext = () => {
+        if (resolvedCount === totalCount) {
+            resolve(results);
+        }
+        else {
+            while (activeCount < concurrency && activeIndex < totalCount) {
+                const currentIndex = activeIndex++;
+                const task = tasks[currentIndex];
+                activeCount++;
+                worker(task)
+                    .then(result => {
+                    results[currentIndex] = result;
+                    resolvedCount++;
+                    activeCount--;
+                    runNext();
+                })
+                    .catch(reject);
+            }
+        }
+    };
+    runNext();
+});

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

@@ -2,15 +2,15 @@ export const lt = (a, b) => a < b;
 export const lte = (a, b) => a <= b;
 export const gt = (a, b) => a > b;
 export const gte = (a, b) => a >= b;
-export const eq = (a, b) => a === b;
-export const neq = (a, b) => a !== b;
+export const eq = (a, b) => Object.is(a, b);
+export const neq = (a, b) => !Object.is(a, b);
 /**
  * Checks two values for value equality. This is a deep equality check that
  * works for all types, including objects and arrays. For objects, it only
  * compares all enumerable keys, no other properties or the prototype chain.
  */
 export const deepEqual = (a, b) => {
-    if (a === b) {
+    if (Object.is(a, b)) {
         return true;
     }
     if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {

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

@@ -1,2 +1,6 @@
-import type { SerializedEntityDecl } from "../../node/schema/index.ts";
-export declare const getSerializedDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;
+import type { SerializedEntityDecl } from "../schema/declarations/EntityDecl.ts";
+export type DisplayNameResult = {
+    name: string;
+    localeId?: string;
+};
+export declare const getSerializedDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales: string[]) => DisplayNameResult;

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

@@ -11,13 +11,16 @@ const getValueAtPath = (value, path) => {
     }
     return current;
 };
-export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales = []) => {
+export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales) => {
     if (entity.displayName === null) {
-        return defaultName;
+        return { name: defaultName, localeId: locales[0] };
     }
     const displayNamePath = entity.displayName ?? "name";
     if (typeof displayNamePath === "string") {
-        return getValueAtPath(instance, displayNamePath) ?? defaultName;
+        return {
+            name: getValueAtPath(instance, displayNamePath) ?? defaultName,
+            localeId: locales[0],
+        };
     }
     else {
         const localeMapPath = displayNamePath.pathToLocaleMap ?? "translations";
@@ -25,12 +28,22 @@ export const getSerializedDisplayNameFromEntityInstance = (entity, instance, def
         const pathInLocaleMap = displayNamePath.pathInLocaleMap ?? "name";
         const availableLocales = Object.keys(localeMap ?? {});
         return availableLocales.length === 0
-            ? defaultName
-            : (locales.reduce((name, locale) => name ??
+            ? { name: defaultName }
+            : (locales.reduce((name, locale) => {
+                if (name)
+                    return name;
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                getValueAtPath(localeMap[locale], pathInLocaleMap), undefined) ??
+                const possibleName = getValueAtPath(localeMap[locale], pathInLocaleMap);
+                if (possibleName) {
+                    return { name: possibleName, localeId: locale };
+                }
+                else {
+                    return undefined;
+                }
+            }, undefined) ?? {
+                name: 
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ??
-                defaultName);
+                getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ?? defaultName,
+            });
     }
 };

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

@@ -2,16 +2,15 @@ import type { EntityDecl } from "../../node/schema/index.ts";
 import type { GetInstanceById } from "../../node/server/index.ts";
 import type { GitFileStatus } from "./git.ts";
 export interface InstanceContainer {
-    fileName: string;
     id: string;
     content: unknown;
     gitStatus?: GitFileStatus;
 }
 export interface InstanceContainerOverview {
-    fileName: string;
     id: string;
     gitStatus?: GitFileStatus;
     displayName: string;
+    displayNameLocaleId?: string;
 }
-export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, locales?: string[]) => InstanceContainerOverview;
+export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, locales: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

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

@@ -1,8 +1,10 @@
 import { getDisplayNameFromEntityInstance } from "../../node/utils/displayName.js";
 export const getInstanceContainerOverview = (entity, instanceContainer, getInstanceById, locales) => {
     const { content: _, ...rest } = instanceContainer;
+    const { name: displayName, localeId: displayNameLocaleId } = getDisplayNameFromEntityInstance(entity, instanceContainer.content, getInstanceById, locales);
     return {
         ...rest,
-        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, getInstanceById, locales),
+        displayName,
+        displayNameLocaleId,
     };
 };

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

@@ -12,6 +12,10 @@ export type InlineMarkdownNode = {
     kind: "link";
     href: string;
     content: InlineMarkdownNode[];
+} | {
+    kind: "attributed";
+    attributes: Record<string, string | number | boolean>;
+    content: InlineMarkdownNode[];
 } | TextNode;
 export type BlockMarkdownNode = {
     kind: "paragraph";

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

@@ -54,7 +54,7 @@ const italicRule = {
     }),
 };
 const linkRule = {
-    pattern: /(?<!\\)\[(.*?[^\\])\]\((.*?[^\\])\)/,
+    pattern: /(?<![\\^])\[(.*?[^\\])\]\((.*?[^\\])\)/,
     map: (result, parseInside) => ({
         kind: "link",
         href: result[2] ?? "",
@@ -66,6 +66,88 @@ const linkRule = {
         content: [textNode("["), ...parseInside(result[1] ?? ""), textNode(`](${result[2] ?? ""})`)],
     }),
 };
+const booleanAttributePattern = /^(true|false)/;
+const numberAttributePattern = /^(-?\d+(\.\d+)?)/;
+const stringAttributePattern = /^("(.*?)(?<!\\)"|'(.*?)(?<!\\)')/;
+const parseAttributeValue = (text) => {
+    const booleanResult = booleanAttributePattern.exec(text);
+    if (booleanResult !== null) {
+        return [booleanResult[1] === "true", booleanResult[0]];
+    }
+    const numberResult = numberAttributePattern.exec(text);
+    if (numberResult !== null) {
+        return [Number.parseFloat(numberResult[1] ?? "0"), numberResult[0]];
+    }
+    const stringResult = stringAttributePattern.exec(text);
+    if (stringResult !== null) {
+        return [stringResult[2] ?? stringResult[3] ?? "", stringResult[0]];
+    }
+    return null;
+};
+const attributeNamePattern = /^(\w+)(: *)/;
+const attributeSeparatorPattern = /^,( *)/;
+const parseNextAttributes = (text) => {
+    const separatorResult = attributeSeparatorPattern.exec(text);
+    if (separatorResult === null) {
+        return [];
+    }
+    const remainingText = text.slice(separatorResult[0].length);
+    return [separatorResult[0], ...parseAttributes(remainingText)];
+};
+const parseAttributes = (text) => {
+    const nameResult = attributeNamePattern.exec(text);
+    if (nameResult === null) {
+        return [];
+    }
+    const name = nameResult[1] ?? "";
+    const separator = nameResult[2] ?? "";
+    const remainingText = text.slice(nameResult[0].length);
+    const valueResult = parseAttributeValue(remainingText);
+    if (valueResult === null) {
+        return [];
+    }
+    const [value, rawValue] = valueResult;
+    return [
+        { name, separator, value, rawValue },
+        ...parseNextAttributes(remainingText.slice(rawValue.length)),
+    ];
+};
+const mapAttributesToObject = (rawAttributes) => Object.fromEntries(rawAttributes.filter(attr => typeof attr !== "string").map(attr => [attr.name, attr.value]));
+const mapAttributesToNodes = (rawAttributes) => rawAttributes.flatMap(attr => typeof attr === "string"
+    ? [textNode(attr)]
+    : [textNode(attr.name), textNode(attr.separator), textNode(attr.rawValue)]);
+const parsedAttributesLength = (rawAttributes) => rawAttributes.reduce((sum, attr) => sum +
+    (typeof attr === "string"
+        ? attr.length
+        : 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) => ({
+        kind: "attributed",
+        attributes: mapAttributesToObject(parseAttributes(result[2] ?? "")),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => {
+        const attributesText = result[2] ?? "";
+        const attributes = parseAttributes(attributesText);
+        const length = parsedAttributesLength(attributes);
+        const unparsedText = attributesText.length > length
+            ? [{ kind: "text", content: attributesText.slice(length) }]
+            : [];
+        return {
+            kind: "attributed",
+            attributes: mapAttributesToObject(attributes),
+            content: [
+                textNode("^["),
+                ...parseInside(result[1] ?? ""),
+                textNode("]("),
+                ...mapAttributesToNodes(attributes),
+                ...unparsedText,
+                textNode(")"),
+            ],
+        };
+    },
+};
 const textNode = (content) => ({
     kind: "text",
     content: content,
@@ -85,6 +167,7 @@ const textRule = {
 const inlineRules = [
     codeRule,
     linkRule,
+    attributedRule,
     boldWithItalicRule,
     italicWithBoldRule,
     boldRule,
@@ -114,6 +197,10 @@ const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
     }
 };
 const parseInlineMarkdown = (text, forSyntaxHighlighting) => parseForInlineRules(inlineRules, text, forSyntaxHighlighting);
+const nodesForTrailingWhitespace = (text) => {
+    const trailingWhitespace = text ?? "";
+    return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
+};
 const listRule = {
     pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|$)/,
     map: result => ({
@@ -133,7 +220,7 @@ const listRule = {
             ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
             ...(index < array.length - 1 ? [textNode("\n")] : []),
         ]),
-        textNode(result[2] ?? ""),
+        ...nodesForTrailingWhitespace(result[2]),
     ],
 };
 const paragraphRule = {
@@ -144,7 +231,7 @@ const paragraphRule = {
     }),
     mapHighlighting: result => [
         ...parseInlineMarkdown(result[1] ?? "", true),
-        textNode(result[2] ?? ""),
+        ...nodesForTrailingWhitespace(result[2]),
     ],
 };
 const removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
@@ -183,7 +270,7 @@ const tableRule = {
                 ? parseInlineMarkdown(tc, true)
                 : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
         ]) ?? []),
-        textNode(result[6] ?? ""),
+        ...nodesForTrailingWhitespace(result[6]),
     ],
 };
 const blockRules = [tableRule, listRule, paragraphRule];

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

@@ -4,3 +4,5 @@ export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<str
 export type Leaves<T> = T extends object ? {
     [K in keyof T]: T[K] extends unknown[] ? never : `${Exclude<K, symbol>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
 }[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; };

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

@@ -8,3 +8,5 @@ export const mergeObjects = (obj1, obj2, solveConflict) => Object.entries(obj2).
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     [key]: Object.hasOwn(acc, key) ? solveConflict(acc[key], value) : value,
 }), 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);

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

@@ -19,7 +19,10 @@ export interface Error<E> {
 /**
  * Creates a result that contains a value.
  */
-export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const ok: {
+    (): Result<void, never>;
+    <T>(value: T): Result<T, never>;
+};
 /**
  * Checks if a result contains a value.
  */
@@ -46,7 +49,10 @@ export declare const map: <T, U, E>(result: Result<T, E>, f: (value: T) => U) =>
 export declare const mapError: <T, E, F>(result: Result<T, E>, f: (value: E) => F) => Result<T, F>;
 export declare const combine: <T1, T2, TR, E1, E2, ER>(result1: Result<T1, E1>, result2: Result<T2, E2>, fok: (value1: T1, value2: T2) => TR, ferror: (error1: E1, error2: E2) => ER) => Result<TR, E1 | E2 | ER>;
 export declare const Result: Readonly<{
-    ok: <T>(value: T) => Result<T, never>;
+    ok: {
+        (): Result<void, never>;
+        <T>(value: T): Result<T, never>;
+    };
     isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
     error: <E>(error: E) => Result<never, E>;
     isError: <T, E>(result: Result<T, E>) => result is Error<E>;

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

@@ -1,7 +1,7 @@
 /**
  * Creates a result that contains a value.
  */
-export const ok = (value) => ({ tag: "Ok", value });
+export const ok = (value) => ({ tag: "Ok", value: value });
 /**
  * Checks if a result contains a value.
  */

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

@@ -0,0 +1,26 @@
+import type { CreatedEntityTaggedInstanceContainerWithChildInstances, UpdatedEntityTaggedInstanceContainerWithChildInstances } from "../../node/utils/childInstances.ts";
+import type { CreateInstanceOfEntityResponseBody, DeleteInstanceOfEntityResponseBody, GetAllChildInstancesOfInstanceResponseBody, GetAllDeclarationsResponseBody, GetAllInstancesOfEntityResponseBody, GetDeclarationResponseBody, GetInstanceOfEntityResponseBody, UpdateInstanceOfEntityResponseBody } from "../../shared/api.ts";
+import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
+import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
+import type { SerializedEnumDecl } from "../../shared/schema/declarations/EnumDecl.ts";
+import type { SerializedTypeAliasDecl } from "../../shared/schema/declarations/TypeAliasDecl.ts";
+type DeclKind = "Entity" | "Enum" | "TypeAlias";
+type DeclTypeForKind<K extends DeclKind | undefined> = K extends "Entity" ? SerializedEntityDecl : K extends "Enum" ? SerializedEnumDecl : K extends "TypeAlias" ? SerializedTypeAliasDecl : SerializedDecl;
+export declare const getAllDeclarations: {
+    (locales: string[], kind?: undefined): Promise<GetAllDeclarationsResponseBody>;
+    <D extends "Entity" | "Enum" | "TypeAlias">(locales: string[], kind: D): Promise<GetAllDeclarationsResponseBody<DeclTypeForKind<D>>>;
+};
+export declare const getAllEntities: (locales: string[]) => Promise<GetAllDeclarationsResponseBody<SerializedEntityDecl<string, {
+    [x: string]: import("../../shared/schema/types/ObjectType.ts").SerializedMemberDecl<import("../../shared/schema/types/Type.ts").SerializedType, boolean>;
+}, string | undefined>>>;
+export declare const getEntityByName: (locales: string[], name: string) => Promise<GetDeclarationResponseBody<SerializedEntityDecl<string, {
+    [x: string]: import("../../shared/schema/types/ObjectType.ts").SerializedMemberDecl<import("../../shared/schema/types/Type.ts").SerializedType, boolean>;
+}, string | undefined>>>;
+export declare const getInstancesByEntityName: (locales: string[], name: string) => Promise<GetAllInstancesOfEntityResponseBody>;
+export declare const getLocaleInstances: (locales: string[], localeEntityName: string | undefined) => Promise<GetAllInstancesOfEntityResponseBody>;
+export declare const createInstanceByEntityNameAndId: (locales: string[], name: string, content: CreatedEntityTaggedInstanceContainerWithChildInstances, id?: string) => Promise<CreateInstanceOfEntityResponseBody>;
+export declare const getInstanceByEntityNameAndId: (locales: string[], name: string, id: string) => Promise<GetInstanceOfEntityResponseBody>;
+export declare const updateInstanceByEntityNameAndId: (locales: string[], name: string, id: string, content: UpdatedEntityTaggedInstanceContainerWithChildInstances) => Promise<UpdateInstanceOfEntityResponseBody>;
+export declare const deleteInstanceByEntityNameAndId: (locales: string[], name: string, id: string) => Promise<DeleteInstanceOfEntityResponseBody>;
+export declare const getChildInstancesForInstanceByEntityName: (locales: string[], name: string, parentId: string) => Promise<GetAllChildInstancesOfInstanceResponseBody>;
+export {};

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

@@ -0,0 +1,51 @@
+import { deleteResource, getResource, postResource, putResource } from "../utils/api.js";
+export const getAllDeclarations = async (locales, kind) => getResource("/api/declarations", {
+    locales,
+    modifyUrl: url => {
+        if (kind) {
+            url.searchParams.append("kind", kind);
+        }
+    },
+});
+export const getAllEntities = (locales) => getAllDeclarations(locales, "Entity");
+export const getEntityByName = async (locales, name) => getResource(`/api/declarations/${name}`, {
+    locales,
+});
+export const getInstancesByEntityName = async (locales, name) => getResource(`/api/declarations/${name}/instances`, {
+    locales,
+});
+export const getLocaleInstances = (locales, localeEntityName) => localeEntityName
+    ? getInstancesByEntityName(locales, localeEntityName)
+    : Promise.resolve({ instances: [], isLocaleEntity: true });
+export const createInstanceByEntityNameAndId = async (locales, name, content, id) => {
+    const body = {
+        instance: content,
+    };
+    return postResource(`/api/declarations/${name}/instances`, {
+        locales,
+        body,
+        modifyUrl: url => {
+            if (id) {
+                url.searchParams.append("id", id);
+            }
+        },
+    });
+};
+export const getInstanceByEntityNameAndId = async (locales, name, id) => getResource(`/api/declarations/${name}/instances/${id}`, {
+    locales,
+});
+export const updateInstanceByEntityNameAndId = async (locales, name, id, content) => {
+    const body = {
+        instance: content,
+    };
+    return putResource(`/api/declarations/${name}/instances/${id}`, {
+        locales,
+        body,
+    });
+};
+export const deleteInstanceByEntityNameAndId = async (locales, name, id) => deleteResource(`/api/declarations/${name}/instances/${id}`, {
+    locales,
+});
+export const getChildInstancesForInstanceByEntityName = async (locales, name, parentId) => getResource(`/api/declarations/${name}/instances/${parentId}/children`, {
+    locales,
+});

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

@@ -0,0 +1,14 @@
+import type { GetAllGitBranchesResponseBody, GitStatusResponseBody } from "../../shared/api.ts";
+export declare const getStatus: (locales: string[]) => Promise<GitStatusResponseBody>;
+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 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>;

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

@@ -0,0 +1,20 @@
+import { getResource, postResource } from "../utils/api.js";
+export const getStatus = async (locales) => getResource("/api/git/status", { 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 commitStagedFiles = async (locales, message) => {
+    const body = { message };
+    return postResource(`/api/git/commit`, { locales, body });
+};
+export const pushCommits = async (locales) => postResource(`/api/git/push`, { locales });
+export const pullCommits = async (locales) => postResource(`/api/git/pull`, { locales });
+export const getBranches = async (locales) => getResource(`/api/git/branch`, { locales });
+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 });

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

@@ -0,0 +1 @@
+export declare const getWebConfig: () => Promise<import("../context/config.ts").WebConfig>;

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

@@ -0,0 +1,2 @@
+import { getResource } from "../utils/api.js";
+export const getWebConfig = () => getResource("/api/config", { locales: [] });

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

@@ -0,0 +1,2 @@
+import type { GetAllInstancesResponseBody } from "../../shared/api.ts";
+export declare const getAllInstances: (locales: string[]) => Promise<GetAllInstancesResponseBody>;

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

@@ -0,0 +1,2 @@
+import { getResource } from "../utils/api.js";
+export const getAllInstances = async (locales) => getResource("/api/instances", { locales });