@ucdjs/ucd-store 0.0.1 → 1.0.1-beta.2

package/README.md

@@ -2,6 +2,7 @@
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![codecov][codecov-src]][codecov-href]
 
 A simple, lightweight store for managing Unicode Character Database Files.
 
@@ -19,3 +20,5 @@ Published under [MIT License](./LICENSE).
 [npm-version-href]: https://npmjs.com/package/@ucdjs/ucd-store
 [npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/ucd-store?style=flat&colorA=18181B&colorB=4169E1
 [npm-downloads-href]: https://npmjs.com/package/@ucdjs/ucd-store
+[codecov-src]: https://img.shields.io/codecov/c/gh/ucdjs/ucd?style=flat&colorA=18181B&colorB=4169E1
+[codecov-href]: https://codecov.io/gh/ucdjs/ucd

package/dist/context-DfX5D4Fb.mjs

@@ -0,0 +1,201 @@
+import { createDebugger } from "@ucdjs-internal/shared";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/errors.ts
+var UCDStoreBaseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UCDStoreBaseError";
+	}
+};
+var UCDStoreGenericError = class extends UCDStoreBaseError {
+	data;
+	constructor(message, data) {
+		super(message);
+		this.name = "UCDStoreGenericError";
+		this.data = data;
+	}
+};
+var UCDStoreFileNotFoundError = class extends UCDStoreBaseError {
+	filePath;
+	version;
+	constructor(filePath, version) {
+		super(`File not found: ${filePath}${version ? ` in version ${version}` : ""}`);
+		this.name = "UCDStoreFileNotFoundError";
+		this.filePath = filePath;
+		this.version = version;
+	}
+};
+var UCDStoreVersionNotFoundError = class extends UCDStoreBaseError {
+	version;
+	constructor(version) {
+		super(`Version '${version}' does not exist in the store.`);
+		this.name = "UCDStoreVersionNotFoundError";
+		this.version = version;
+	}
+};
+var UCDStoreBridgeUnsupportedOperation = class extends UCDStoreBaseError {
+	operation;
+	requiredCapabilities;
+	availableCapabilities;
+	constructor(operation, requiredCapabilities, availableCapabilities) {
+		let message = `Operation "${operation}" is not supported.`;
+		if (requiredCapabilities.length > 0 || availableCapabilities.length > 0) message += ` Required capabilities: ${requiredCapabilities.join(", ")}. Available capabilities: ${availableCapabilities.join(", ")}`;
+		super(message);
+		this.name = "UCDStoreBridgeUnsupportedOperation";
+		this.operation = operation;
+		this.requiredCapabilities = requiredCapabilities;
+		this.availableCapabilities = availableCapabilities;
+	}
+};
+var UCDStoreFilterError = class extends UCDStoreBaseError {
+	excludePattern = [];
+	includePattern = [];
+	filePath;
+	constructor(message, { excludePattern, includePattern, filePath }) {
+		super(message);
+		this.name = "UCDStoreFilterError";
+		this.excludePattern = excludePattern;
+		this.includePattern = includePattern;
+		this.filePath = filePath;
+	}
+};
+var UCDStoreApiFallbackError = class extends UCDStoreBaseError {
+	version;
+	filePath;
+	status;
+	reason;
+	constructor({ version, filePath, status, reason, message }) {
+		const defaultMessage = reason === "fetch-failed" ? `Failed to fetch file '${filePath}' from API${status ? ` (status: ${status})` : ""}` : `API returned no data for file '${filePath}'`;
+		super(message ?? defaultMessage);
+		this.name = "UCDStoreApiFallbackError";
+		this.version = version;
+		this.filePath = filePath;
+		this.status = status;
+		this.reason = reason;
+	}
+};
+
+//#endregion
+//#region src/context.ts
+var context_exports = /* @__PURE__ */ __exportAll({
+	createInternalContext: () => createInternalContext,
+	createPublicContext: () => createPublicContext,
+	extractFilterPatterns: () => extractFilterPatterns,
+	isUCDStoreInternalContext: () => isUCDStoreInternalContext
+});
+const debug = createDebugger("ucdjs:ucd-store:context");
+/**
+* Creates an internal store context object.
+* This context is used internally by store methods and operations.
+*
+* @internal
+*/
+function createInternalContext(options) {
+	let apiVersionsCache = null;
+	return {
+		client: options.client,
+		filter: options.filter,
+		fs: options.fs,
+		lockfile: {
+			supports: options.lockfile.supports,
+			exists: options.lockfile.exists,
+			path: options.lockfile.path
+		},
+		versions: {
+			userProvided: Object.freeze([...options.versions.userProvided]),
+			configFile: Object.freeze([...options.versions.configFile]),
+			resolved: options.versions.resolved ? [...options.versions.resolved] : [],
+			async apiVersions() {
+				if (apiVersionsCache !== null) {
+					debug?.("Using cached API versions");
+					return apiVersionsCache;
+				}
+				debug?.("Fetching API versions");
+				const result = await options.client.versions.list();
+				if (result.error || !result.data) {
+					debug?.("Failed to fetch API versions:", result.error);
+					apiVersionsCache = Object.freeze([]);
+					return apiVersionsCache;
+				}
+				const versionStrings = result.data.map((v) => v.version);
+				apiVersionsCache = Object.freeze(versionStrings);
+				debug?.("Cached API versions:", apiVersionsCache);
+				return apiVersionsCache;
+			}
+		},
+		async getExpectedFilePaths(version) {
+			debug?.("Fetching expected files for version:", version);
+			const result = await options.client.manifest.get(version);
+			if (result.error) throw new UCDStoreGenericError(`Failed to fetch expected files for version '${version}': ${result.error.message}`, {
+				version,
+				status: result.error.status
+			});
+			if (!result.data) throw new UCDStoreGenericError(`Failed to fetch expected files for version '${version}': empty response`, { version });
+			if (!Array.isArray(result.data.expectedFiles)) throw new UCDStoreGenericError(`Failed to fetch expected files for version '${version}': invalid response (missing expectedFiles)`, { version });
+			return result.data.expectedFiles;
+		}
+	};
+}
+function isUCDStoreInternalContext(obj) {
+	return !!obj && typeof obj === "object" && "versions" in obj && typeof obj.versions === "object" && obj.versions != null && "resolved" in obj.versions && Array.isArray(obj.versions?.resolved);
+}
+/**
+* Extracts filter patterns from a PathFilter for storage in the lockfile.
+*
+* @param {PathFilter} filter - The path filter to extract patterns from
+* @returns {PathFilterOptions | undefined} The filter options, or undefined if no filters are configured
+* @internal
+*/
+function extractFilterPatterns(filter) {
+	const patterns = filter.patterns();
+	const hasInclude = patterns.include && patterns.include.length > 0;
+	const hasExclude = patterns.exclude && patterns.exclude.length > 0;
+	const hasDisableDefault = patterns.disableDefaultExclusions === true;
+	if (!hasInclude && !hasExclude && !hasDisableDefault) return;
+	function ensureArray(value) {
+		if (!value) return [];
+		return Array.isArray(value) ? value : [value];
+	}
+	debug?.(`Extracting filter patterns: include=${hasInclude}, exclude=${hasExclude}, disableDefaultExclusions=${hasDisableDefault}`);
+	return {
+		include: ensureArray(patterns.include),
+		exclude: ensureArray(patterns.exclude),
+		disableDefaultExclusions: patterns.disableDefaultExclusions
+	};
+}
+/**
+* Creates the public-facing context properties from internal context.
+* This includes only the properties that should be exposed in the public API.
+*
+* @internal
+*/
+function createPublicContext(context) {
+	return {
+		get versions() {
+			return Object.freeze([...context.versions.resolved]);
+		},
+		get fs() {
+			return context.fs;
+		}
+	};
+}
+
+//#endregion
+export { isUCDStoreInternalContext as a, UCDStoreBridgeUnsupportedOperation as c, UCDStoreGenericError as d, UCDStoreVersionNotFoundError as f, extractFilterPatterns as i, UCDStoreFileNotFoundError as l, createInternalContext as n, UCDStoreApiFallbackError as o, createPublicContext as r, UCDStoreBaseError as s, context_exports as t, UCDStoreFilterError as u };