@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/serialization/compare.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareItems = void 0;
+const stripNewlines = (value) => value.replace(/\r/g, "").replace(/\n/g, "");
+const getFieldDifferences = (left, right) => {
+    const leftIndex = new Map(left.map((field) => [field.fieldId, field]));
+    const rightIndex = new Map(right.map((field) => [field.fieldId, field]));
+    const results = [];
+    for (const [id, field] of leftIndex) {
+        if (!rightIndex.has(id)) {
+            results.push({ leftField: field, rightField: null });
+        }
+    }
+    for (const [id, field] of rightIndex) {
+        if (!leftIndex.has(id)) {
+            results.push({ leftField: null, rightField: field });
+        }
+    }
+    for (const [id, rightField] of rightIndex) {
+        const leftField = leftIndex.get(id);
+        if (!leftField) {
+            continue;
+        }
+        const leftValue = leftField.value ?? "";
+        const rightValue = rightField.value ?? "";
+        const blobDifferent = leftField.blobId && rightField.blobId && leftField.blobId !== rightField.blobId;
+        if (blobDifferent || stripNewlines(leftValue) !== stripNewlines(rightValue)) {
+            results.push({ leftField, rightField });
+        }
+    }
+    return results;
+};
+const getUnversionedDifferences = (left, right) => {
+    const results = [];
+    const leftIndex = new Map(left.unversionedFields.map((language) => [language.language, language]));
+    const rightIndex = new Map(right.unversionedFields.map((language) => [language.language, language]));
+    for (const [language, rightLanguage] of rightIndex) {
+        if (!leftIndex.has(language)) {
+            results.push({
+                language: rightLanguage,
+                changedFields: rightLanguage.fields.map((field) => ({
+                    leftField: null,
+                    rightField: field,
+                })),
+            });
+        }
+    }
+    for (const [language, leftLanguage] of leftIndex) {
+        if (!rightIndex.has(language)) {
+            results.push({
+                language: leftLanguage,
+                changedFields: leftLanguage.fields.map((field) => ({ leftField: field, rightField: null })),
+            });
+        }
+    }
+    for (const [language, leftLanguage] of leftIndex) {
+        const rightLanguage = rightIndex.get(language);
+        if (!rightLanguage) {
+            continue;
+        }
+        const changes = getFieldDifferences(leftLanguage.fields, rightLanguage.fields);
+        if (changes.length > 0) {
+            results.push({ language: leftLanguage, changedFields: changes });
+        }
+    }
+    return results;
+};
+const getVersionDifferences = (left, right) => {
+    const results = [];
+    const findVersion = (item, language, version) => item.versions.find((ver) => ver.language.toLowerCase() === language.toLowerCase() && ver.version === version);
+    for (const rightVersion of right.versions) {
+        if (!findVersion(left, rightVersion.language, rightVersion.version)) {
+            results.push({
+                leftVersion: null,
+                rightVersion,
+                changedFields: rightVersion.fields.map((field) => ({ leftField: null, rightField: field })),
+                versionNumber: rightVersion.version,
+                language: rightVersion.language,
+            });
+        }
+    }
+    for (const leftVersion of left.versions) {
+        if (!findVersion(right, leftVersion.language, leftVersion.version)) {
+            results.push({
+                leftVersion,
+                rightVersion: null,
+                changedFields: leftVersion.fields.map((field) => ({ leftField: field, rightField: null })),
+                versionNumber: leftVersion.version,
+                language: leftVersion.language,
+            });
+        }
+    }
+    for (const leftVersion of left.versions) {
+        const rightVersion = findVersion(right, leftVersion.language, leftVersion.version);
+        if (!rightVersion) {
+            continue;
+        }
+        const changedFields = getFieldDifferences(leftVersion.fields, rightVersion.fields);
+        if (changedFields.length > 0) {
+            results.push({
+                leftVersion,
+                rightVersion,
+                changedFields,
+                versionNumber: leftVersion.version,
+                language: leftVersion.language,
+            });
+        }
+    }
+    return results;
+};
+const compareItems = (left, right) => {
+    return {
+        leftItem: left,
+        rightItem: right,
+        isRenamed: left.name !== right.name,
+        isMoved: left.parentId !== right.parentId,
+        isTemplateChanged: left.templateId !== right.templateId,
+        isBranchChanged: (left.branchId ?? "") !== (right.branchId ?? ""),
+        changedSharedFields: getFieldDifferences(left.sharedFields, right.sharedFields),
+        changedUnversionedFields: getUnversionedDifferences(left, right),
+        changedVersions: getVersionDifferences(left, right),
+    };
+};
+exports.compareItems = compareItems;

package/dist/serialization/field-filter.d.ts

@@ -0,0 +1,7 @@
+import { FieldFilter } from "./types";
+export type FieldFilterSet = {
+    excludes: Set<string>;
+};
+export declare const createFieldFilterSet: (rootExcluded: FieldFilter[], moduleExcluded: FieldFilter[]) => FieldFilterSet;
+export declare const filterFieldIds: (filterSet: FieldFilterSet) => string[];
+//# sourceMappingURL=field-filter.d.ts.map

package/dist/serialization/field-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-filter.d.ts","sourceRoot":"","sources":["../../src/serialization/field-filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,cAAc,WAAW,EAAE,EAC3B,gBAAgB,WAAW,EAAE,KAC5B,cAcF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,WAAW,cAAc,KAAG,MAAM,EACxB,CAAC"}

package/dist/serialization/field-filter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterFieldIds = exports.createFieldFilterSet = void 0;
+const createFieldFilterSet = (rootExcluded, moduleExcluded) => {
+    const set = new Set();
+    for (const field of rootExcluded) {
+        if (field.fieldId) {
+            set.add(field.fieldId.toLowerCase());
+        }
+    }
+    for (const field of moduleExcluded) {
+        if (field.fieldId) {
+            set.add(field.fieldId.toLowerCase());
+        }
+    }
+    return { excludes: set };
+};
+exports.createFieldFilterSet = createFieldFilterSet;
+const filterFieldIds = (filterSet) => Array.from(filterSet.excludes.values());
+exports.filterFieldIds = filterFieldIds;

package/dist/serialization/filesystem-store/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ROLES_FOLDER_SUFFIX = "_roles";
+export declare const USERS_FOLDER_SUFFIX = "_users";
+//# sourceMappingURL=constants.d.ts.map

package/dist/serialization/filesystem-store/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,WAAW,CAAC;AAC5C,eAAO,MAAM,mBAAmB,WAAW,CAAC"}

package/dist/serialization/filesystem-store/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USERS_FOLDER_SUFFIX = exports.ROLES_FOLDER_SUFFIX = void 0;
+exports.ROLES_FOLDER_SUFFIX = "_roles";
+exports.USERS_FOLDER_SUFFIX = "_users";

package/dist/serialization/filesystem-store/index.d.ts

@@ -0,0 +1,4 @@
+export { loadFilesystemItems, writeItemToFilesystem, removeItemFromFilesystem } from "./items";
+export { readRolesFromFilesystem, writeRoleToFilesystem, removeRoleFromFilesystem } from "./roles";
+export { readUsersFromFilesystem, writeUserToFilesystem, removeUserFromFilesystem } from "./users";
+//# sourceMappingURL=index.d.ts.map

package/dist/serialization/filesystem-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAC/F,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACnG,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}

package/dist/serialization/filesystem-store/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUserFromFilesystem = exports.writeUserToFilesystem = exports.readUsersFromFilesystem = exports.removeRoleFromFilesystem = exports.writeRoleToFilesystem = exports.readRolesFromFilesystem = exports.removeItemFromFilesystem = exports.writeItemToFilesystem = exports.loadFilesystemItems = void 0;
+var items_1 = require("./items");
+Object.defineProperty(exports, "loadFilesystemItems", { enumerable: true, get: function () { return items_1.loadFilesystemItems; } });
+Object.defineProperty(exports, "writeItemToFilesystem", { enumerable: true, get: function () { return items_1.writeItemToFilesystem; } });
+Object.defineProperty(exports, "removeItemFromFilesystem", { enumerable: true, get: function () { return items_1.removeItemFromFilesystem; } });
+var roles_1 = require("./roles");
+Object.defineProperty(exports, "readRolesFromFilesystem", { enumerable: true, get: function () { return roles_1.readRolesFromFilesystem; } });
+Object.defineProperty(exports, "writeRoleToFilesystem", { enumerable: true, get: function () { return roles_1.writeRoleToFilesystem; } });
+Object.defineProperty(exports, "removeRoleFromFilesystem", { enumerable: true, get: function () { return roles_1.removeRoleFromFilesystem; } });
+var users_1 = require("./users");
+Object.defineProperty(exports, "readUsersFromFilesystem", { enumerable: true, get: function () { return users_1.readUsersFromFilesystem; } });
+Object.defineProperty(exports, "writeUserToFilesystem", { enumerable: true, get: function () { return users_1.writeUserToFilesystem; } });
+Object.defineProperty(exports, "removeUserFromFilesystem", { enumerable: true, get: function () { return users_1.removeUserFromFilesystem; } });

package/dist/serialization/filesystem-store/items.d.ts

@@ -0,0 +1,10 @@
+import { FilesystemTreeSpec } from "../tree-spec";
+import { ItemData, ItemMetadata } from "../types";
+import { FilesystemPathProvider } from "../path-provider";
+export declare const loadFilesystemItems: (subtrees: FilesystemTreeSpec[]) => Promise<{
+    items: ItemData[];
+    metadata: ItemMetadata[];
+}>;
+export declare const writeItemToFilesystem: (pathProvider: FilesystemPathProvider, item: ItemData) => Promise<string>;
+export declare const removeItemFromFilesystem: (pathProvider: FilesystemPathProvider, item: ItemMetadata) => Promise<void>;
+//# sourceMappingURL=items.d.ts.map

package/dist/serialization/filesystem-store/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/items.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAElD,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,mBAAmB,GAC9B,UAAU,kBAAkB,EAAE,KAC7B,OAAO,CAAC;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAmCzD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,cAAc,sBAAsB,EACpC,MAAM,QAAQ,KACb,OAAO,CAAC,MAAM,CAUhB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,cAAc,sBAAsB,EACpC,MAAM,YAAY,KACjB,OAAO,CAAC,IAAI,CAMd,CAAC"}

package/dist/serialization/filesystem-store/items.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeItemFromFilesystem = exports.writeItemToFilesystem = exports.loadFilesystemItems = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const errors_1 = require("../../shared/errors");
+const yaml_1 = require("../yaml");
+const signature_1 = require("../signature");
+const loadFilesystemItems = async (subtrees) => {
+    const results = [];
+    for (const subtree of subtrees) {
+        const files = await (0, fast_glob_1.default)("**/*.yml", {
+            cwd: subtree.physicalPath,
+            absolute: true,
+            onlyFiles: true,
+        });
+        for (const file of files) {
+            const item = await (0, yaml_1.readItemYaml)(file);
+            if (!subtree.includesPath(item.path)) {
+                continue;
+            }
+            if (!item.database) {
+                item.database = subtree.database;
+            }
+            if (!item.dataSignature) {
+                const base = (0, signature_1.createDataSignatureBase)(item);
+                item.dataSignature = (0, signature_1.createSignature)(base) ?? "";
+            }
+            results.push(item);
+        }
+    }
+    const metadata = results.map((item) => ({
+        id: item.id,
+        parentId: item.parentId,
+        templateId: item.templateId,
+        path: item.path,
+        dataSignature: item.dataSignature,
+    }));
+    return { items: results, metadata };
+};
+exports.loadFilesystemItems = loadFilesystemItems;
+const writeItemToFilesystem = async (pathProvider, item) => {
+    const targetPath = pathProvider.getPhysicalPathForItemPath(item.path, ".yml");
+    if (!targetPath) {
+        throw (0, errors_1.createCliError)(`Unable to resolve file path for ${item.path}`, "INPUT_INVALID");
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
+    const content = (0, yaml_1.writeItemYaml)(item);
+    await promises_1.default.writeFile(targetPath, content, "utf8");
+    return targetPath;
+};
+exports.writeItemToFilesystem = writeItemToFilesystem;
+const removeItemFromFilesystem = async (pathProvider, item) => {
+    const targetPath = pathProvider.getPhysicalPathForItemPath(item.path, ".yml");
+    if (!targetPath) {
+        return;
+    }
+    await promises_1.default.rm(targetPath, { force: true });
+};
+exports.removeItemFromFilesystem = removeItemFromFilesystem;

package/dist/serialization/filesystem-store/roles.d.ts

@@ -0,0 +1,6 @@
+import { RoleData } from "../types";
+import { RootConfiguration, SerializationModuleConfiguration } from "../../config";
+export declare const readRolesFromFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration) => Promise<RoleData[]>;
+export declare const writeRoleToFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration, role: RoleData) => Promise<string>;
+export declare const removeRoleFromFilesystem: (rolePath?: string) => Promise<void>;
+//# sourceMappingURL=roles.d.ts.map

package/dist/serialization/filesystem-store/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/roles.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;AAI/E,eAAO,MAAM,uBAAuB,GAClC,YAAY,iBAAiB,EAC7B,cAAc,gCAAgC,KAC7C,OAAO,CAAC,QAAQ,EAAE,CAmBpB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,iBAAiB,EAC7B,cAAc,gCAAgC,EAC9C,MAAM,QAAQ,KACb,OAAO,CAAC,MAAM,CAehB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAK9E,CAAC"}

package/dist/serialization/filesystem-store/roles.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeRoleFromFilesystem = exports.writeRoleToFilesystem = exports.readRolesFromFilesystem = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const yaml_1 = require("../yaml");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const readRolesFromFilesystem = async (rootConfig, moduleConfig) => {
+    const moduleDir = node_path_1.default.dirname(moduleConfig.sourceIdentifier);
+    const rolesPath = node_path_1.default.join(moduleDir, rootConfig.serialization.defaultModuleRelativeSerializationPath, constants_1.ROLES_FOLDER_SUFFIX);
+    if (!(await (0, utils_1.exists)(rolesPath))) {
+        return [];
+    }
+    const files = await (0, fast_glob_1.default)("**/*.yml", { cwd: rolesPath, absolute: true, onlyFiles: true });
+    const results = [];
+    for (const file of files) {
+        const content = await promises_1.default.readFile(file, "utf8");
+        results.push((0, yaml_1.readRoleYamlFromString)(content, file));
+    }
+    return results;
+};
+exports.readRolesFromFilesystem = readRolesFromFilesystem;
+const writeRoleToFilesystem = async (rootConfig, moduleConfig, role) => {
+    const moduleDir = node_path_1.default.dirname(moduleConfig.sourceIdentifier);
+    const roleNameParts = role.roleName.split("\\");
+    const domain = roleNameParts[0] ?? "default";
+    const name = roleNameParts[1] ?? role.roleName;
+    const roleDir = node_path_1.default.join(moduleDir, rootConfig.serialization.defaultModuleRelativeSerializationPath, constants_1.ROLES_FOLDER_SUFFIX, domain);
+    await promises_1.default.mkdir(roleDir, { recursive: true });
+    const filePath = node_path_1.default.join(roleDir, `${name}.yml`);
+    await promises_1.default.writeFile(filePath, (0, yaml_1.writeRoleYaml)(role), "utf8");
+    return filePath;
+};
+exports.writeRoleToFilesystem = writeRoleToFilesystem;
+const removeRoleFromFilesystem = async (rolePath) => {
+    if (!rolePath) {
+        return;
+    }
+    await promises_1.default.rm(rolePath, { force: true });
+};
+exports.removeRoleFromFilesystem = removeRoleFromFilesystem;

package/dist/serialization/filesystem-store/users.d.ts

@@ -0,0 +1,6 @@
+import { UserData } from "../types";
+import { RootConfiguration, SerializationModuleConfiguration } from "../../config";
+export declare const readUsersFromFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration) => Promise<UserData[]>;
+export declare const writeUserToFilesystem: (rootConfig: RootConfiguration, moduleConfig: SerializationModuleConfiguration, user: UserData) => Promise<string>;
+export declare const removeUserFromFilesystem: (userPath?: string) => Promise<void>;
+//# sourceMappingURL=users.d.ts.map

package/dist/serialization/filesystem-store/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/users.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;AAI/E,eAAO,MAAM,uBAAuB,GAClC,YAAY,iBAAiB,EAC7B,cAAc,gCAAgC,KAC7C,OAAO,CAAC,QAAQ,EAAE,CAmBpB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,iBAAiB,EAC7B,cAAc,gCAAgC,EAC9C,MAAM,QAAQ,KACb,OAAO,CAAC,MAAM,CAehB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAK9E,CAAC"}

package/dist/serialization/filesystem-store/users.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUserFromFilesystem = exports.writeUserToFilesystem = exports.readUsersFromFilesystem = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const yaml_1 = require("../yaml");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const readUsersFromFilesystem = async (rootConfig, moduleConfig) => {
+    const moduleDir = node_path_1.default.dirname(moduleConfig.sourceIdentifier);
+    const usersPath = node_path_1.default.join(moduleDir, rootConfig.serialization.defaultModuleRelativeSerializationPath, constants_1.USERS_FOLDER_SUFFIX);
+    if (!(await (0, utils_1.exists)(usersPath))) {
+        return [];
+    }
+    const files = await (0, fast_glob_1.default)("**/*.yml", { cwd: usersPath, absolute: true, onlyFiles: true });
+    const results = [];
+    for (const file of files) {
+        const content = await promises_1.default.readFile(file, "utf8");
+        results.push((0, yaml_1.readUserYamlFromString)(content, file));
+    }
+    return results;
+};
+exports.readUsersFromFilesystem = readUsersFromFilesystem;
+const writeUserToFilesystem = async (rootConfig, moduleConfig, user) => {
+    const moduleDir = node_path_1.default.dirname(moduleConfig.sourceIdentifier);
+    const usernameParts = user.userName.split("\\");
+    const domain = usernameParts[0] ?? "default";
+    const name = usernameParts[1] ?? user.userName;
+    const userDir = node_path_1.default.join(moduleDir, rootConfig.serialization.defaultModuleRelativeSerializationPath, constants_1.USERS_FOLDER_SUFFIX, domain);
+    await promises_1.default.mkdir(userDir, { recursive: true });
+    const filePath = node_path_1.default.join(userDir, `${name}.yml`);
+    await promises_1.default.writeFile(filePath, (0, yaml_1.writeUserYaml)(user), "utf8");
+    return filePath;
+};
+exports.writeUserToFilesystem = writeUserToFilesystem;
+const removeUserFromFilesystem = async (userPath) => {
+    if (!userPath) {
+        return;
+    }
+    await promises_1.default.rm(userPath, { force: true });
+};
+exports.removeUserFromFilesystem = removeUserFromFilesystem;

package/dist/serialization/filesystem-store/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const exists: (value: string) => Promise<boolean>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/serialization/filesystem-store/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/serialization/filesystem-store/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,GAAU,OAAO,MAAM,KAAG,OAAO,CAAC,OAAO,CAO3D,CAAC"}

package/dist/serialization/filesystem-store/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const exists = async (value) => {
+    try {
+        await promises_1.default.access(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.exists = exists;

package/dist/serialization/filesystem-store.d.ts

@@ -0,0 +1,2 @@
+export * from "./filesystem-store/index";
+//# sourceMappingURL=filesystem-store.d.ts.map

package/dist/serialization/filesystem-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-store.d.ts","sourceRoot":"","sources":["../../src/serialization/filesystem-store.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dist/serialization/filesystem-store.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./filesystem-store/index"), exports);

package/dist/serialization/item-path.d.ts

@@ -0,0 +1,32 @@
+export interface ItemPathMatchLike {
+    isMatch: (path: ItemPath) => boolean;
+    toPathString: () => string;
+}
+export declare class ItemPath implements ItemPathMatchLike {
+    private readonly segments;
+    private baseString;
+    private constructor();
+    static fromPathString(pathString: string): ItemPath;
+    static fromSegments(segments: string[]): ItemPath;
+    get count(): number;
+    get itemName(): string | null;
+    get pathLength(): number;
+    toPathString(): string;
+    toString(): string;
+    equals(other: ItemPath | null): boolean;
+    createParentPath(): ItemPath | null;
+    prepend(segment: string): ItemPath;
+    concatenate(segment: string | ItemPath): ItemPath;
+    createRelativePathFrom(root: ItemPath): ItemPath | null;
+    isDescendantOrSelfOf(basePath: ItemPath | ItemPathMatchLike): boolean;
+    isMatch(path: ItemPath): boolean;
+}
+export declare class ItemPathMatch implements ItemPathMatchLike {
+    private readonly pathMatch;
+    private constructor();
+    static fromPathMatch(pathWildcard: string): ItemPathMatch;
+    isMatch(path: ItemPath): boolean;
+    toPathString(): string;
+    toString(): string;
+}
+//# sourceMappingURL=item-path.d.ts.map

package/dist/serialization/item-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-path.d.ts","sourceRoot":"","sources":["../../src/serialization/item-path.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC;IACrC,YAAY,EAAE,MAAM,MAAM,CAAC;CAC5B;AAED,qBAAa,QAAS,YAAW,iBAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO;IAKP,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ;IASnD,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,QAAQ;IAIjD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,QAAQ,IAAI,MAAM,GAAG,IAAI,CAE5B;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,YAAY,IAAI,MAAM;IAQtB,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO;IAcvC,gBAAgB,IAAI,QAAQ,GAAG,IAAI;IAQnC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ;IAQlC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ;IAYjD,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI;IAoBvD,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,GAAG,OAAO;IAkBrE,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;CAGjC;AAED,qBAAa,aAAc,YAAW,iBAAiB;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO;IAIP,MAAM,CAAC,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa;IAIzD,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;IAIhC,YAAY,IAAI,MAAM;IAItB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/serialization/item-path.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemPathMatch = exports.ItemPath = void 0;
+const errors_1 = require("../shared/errors");
+const wildcard_1 = require("./wildcard");
+class ItemPath {
+    constructor(segments, baseString) {
+        this.segments = segments.map((segment) => segment);
+        this.baseString = baseString ?? null;
+    }
+    static fromPathString(pathString) {
+        if (!pathString || !pathString.startsWith("/")) {
+            throw (0, errors_1.createCliError)(`Item path '${pathString}' did not start with /.`, "INPUT_INVALID");
+        }
+        const segments = pathString.split("/").filter(Boolean);
+        return new ItemPath(segments, pathString.replace(/\/+$/, ""));
+    }
+    static fromSegments(segments) {
+        return new ItemPath([...segments]);
+    }
+    get count() {
+        return this.segments.length;
+    }
+    get itemName() {
+        return this.segments.length > 0 ? this.segments[this.segments.length - 1] : null;
+    }
+    get pathLength() {
+        return this.segments.reduce((sum, segment) => sum + segment.length, 0) + this.segments.length;
+    }
+    toPathString() {
+        if (!this.baseString) {
+            this.baseString = "/" + this.segments.join("/");
+        }
+        return this.baseString;
+    }
+    toString() {
+        return this.toPathString();
+    }
+    equals(other) {
+        if (!other || other.count !== this.count) {
+            return false;
+        }
+        for (let i = 0; i < this.segments.length; i += 1) {
+            if (this.segments[i].toLowerCase() !== other.segments[i].toLowerCase()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    createParentPath() {
+        if (this.segments.length < 1) {
+            return null;
+        }
+        return new ItemPath(this.segments.slice(0, -1));
+    }
+    prepend(segment) {
+        if (!segment || segment.includes("/")) {
+            throw (0, errors_1.createCliError)("Cannot prepend multiple segments.", "INPUT_INVALID");
+        }
+        return new ItemPath([segment, ...this.segments]);
+    }
+    concatenate(segment) {
+        if (typeof segment === "string") {
+            if (!segment || segment.includes("/")) {
+                throw (0, errors_1.createCliError)("Cannot concatenate multiple segments using string.", "INPUT_INVALID");
+            }
+            return new ItemPath([...this.segments, segment]);
+        }
+        return new ItemPath([...this.segments, ...segment.segments]);
+    }
+    createRelativePathFrom(root) {
+        if (root.count > this.count) {
+            return null;
+        }
+        const result = [];
+        for (let i = 0; i < this.segments.length; i += 1) {
+            const isWithinRoot = i < root.count;
+            if (isWithinRoot && this.segments[i].toLowerCase() !== root.segments[i].toLowerCase()) {
+                return null;
+            }
+            if (!isWithinRoot) {
+                result.push(this.segments[i]);
+            }
+        }
+        return new ItemPath(result);
+    }
+    isDescendantOrSelfOf(basePath) {
+        if (basePath instanceof ItemPath) {
+            if (basePath.count > this.count) {
+                return false;
+            }
+            for (let i = 0; i < basePath.count; i += 1) {
+                if (this.segments[i].toLowerCase() !== basePath.segments[i].toLowerCase()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return basePath.isMatch(this);
+    }
+    isMatch(path) {
+        return path.isDescendantOrSelfOf(this);
+    }
+}
+exports.ItemPath = ItemPath;
+class ItemPathMatch {
+    constructor(pathMatch) {
+        this.pathMatch = pathMatch;
+    }
+    static fromPathMatch(pathWildcard) {
+        return new ItemPathMatch(pathWildcard);
+    }
+    isMatch(path) {
+        return (0, wildcard_1.isWildcardMatch)(path.toPathString(), this.pathMatch, false);
+    }
+    toPathString() {
+        return this.pathMatch;
+    }
+    toString() {
+        return this.toPathString();
+    }
+}
+exports.ItemPathMatch = ItemPathMatch;

package/dist/serialization/path-provider.d.ts

@@ -0,0 +1,12 @@
+import { FilesystemTreeSpec } from "./tree-spec";
+import { ItemPath } from "./item-path";
+export declare class FilesystemPathProvider {
+    private readonly subtrees;
+    private examplePath;
+    constructor(subtreeSpecs: FilesystemTreeSpec[]);
+    getPhysicalPathForItemPath(itemPath: ItemPath, extension: string): string | null;
+    getChildrenPathsForItemPath(itemPath: ItemPath): string[] | null;
+    toString(): string;
+    private invokeUnique;
+}
+//# sourceMappingURL=path-provider.d.ts.map

package/dist/serialization/path-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-provider.d.ts","sourceRoot":"","sources":["../../src/serialization/path-provider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAA0B,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAuSvC,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsD;IAC/E,OAAO,CAAC,WAAW,CAAM;gBAEb,YAAY,EAAE,kBAAkB,EAAE;IAQ9C,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMhF,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,GAAG,IAAI;IAIhE,QAAQ,IAAI,MAAM;IAIlB,OAAO,CAAC,YAAY;CAuBrB"}