@tinya-code/gas-admin-ui 0.2.0-alpha.15 → 0.2.0-alpha.17

package/fesm2022/tinya-code-gas-admin-ui-schema-catalog-D0Pk0wAN.mjs

@@ -0,0 +1,685 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Injector, Service, computed, inject, provideAppInitializer, signal } from "@angular/core";
+import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams, HttpResponse, provideHttpClient, withInterceptors } from "@angular/common/http";
+import { catchError, firstValueFrom, forkJoin, from, map, of, switchMap, tap, throwError } from "rxjs";
+import { Router } from "@angular/router";
+var ApiError = class extends Error {
+	status;
+	fieldPath;
+	code;
+	issues;
+	constructor(status, message, fieldPath, code, issues = []) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.fieldPath = fieldPath;
+		this.code = code;
+		this.issues = issues;
+	}
+};
+function renewedTokenOf(body) {
+	if (body === null || typeof body !== "object") return null;
+	const meta = body.meta;
+	if (meta === null || typeof meta !== "object") return null;
+	const token = meta.renewedToken;
+	return typeof token === "string" && token !== "" ? token : null;
+}
+const API_URL = new InjectionToken("API_URL");
+const FIREBASE_AUTH_ADAPTER = new InjectionToken("gas.admin.firebaseAuthAdapter");
+const API_DRIVER = new InjectionToken("gas.admin.driver");
+const VALUE_SOURCES = new InjectionToken("gas.admin.valueSources");
+const DEFAULT_RESPONSE_UNWRAP = new InjectionToken("gas.admin.defaultResponseUnwrap");
+const LOGIN_PATH = "/login";
+const SESSION_TOKEN_KEY = "admin.session.token";
+const SESSION_USER_KEY = "admin.session.user";
+var AuthService = class AuthService {
+	http = inject(HttpClient);
+	apiUrl = inject(API_URL);
+	router = inject(Router);
+	firebaseAdapter = inject(FIREBASE_AUTH_ADAPTER, { optional: true });
+	driver = inject(API_DRIVER, { optional: true }) ?? "gas";
+	storage = sessionStorage;
+	_user = signal(null, ...ngDevMode ? [{ debugName: "_user" }] : /* istanbul ignore next */ []);
+	_token = signal(null, ...ngDevMode ? [{ debugName: "_token" }] : /* istanbul ignore next */ []);
+	_returnUrl = signal(null, ...ngDevMode ? [{ debugName: "_returnUrl" }] : /* istanbul ignore next */ []);
+	user = this._user.asReadonly();
+	token = this._token.asReadonly();
+	returnUrl = this._returnUrl.asReadonly();
+	isAuthenticated = computed(() => this._token() !== null && this._user() !== null, ...ngDevMode ? [{ debugName: "isAuthenticated" }] : /* istanbul ignore next */ []);
+	role = computed(() => this._user()?.role ?? "", ...ngDevMode ? [{ debugName: "role" }] : /* istanbul ignore next */ []);
+	constructor() {
+		const token = this.storage.getItem(SESSION_TOKEN_KEY);
+		if (token !== null && token !== "") this._token.set(token);
+		const raw = this.storage.getItem(SESSION_USER_KEY);
+		if (raw !== null && raw !== "") try {
+			this._user.set(JSON.parse(raw));
+		} catch {
+			this.storage.removeItem(SESSION_USER_KEY);
+			this.storage.removeItem(SESSION_TOKEN_KEY);
+			this._token.set(null);
+		}
+	}
+	login(email, password) {
+		return this.post("/auth/login", {
+			email,
+			password
+		}).pipe(map((res) => {
+			this.open(res.token, res.user);
+			const renewed = renewedTokenOf(res);
+			if (renewed !== null) this.applyRenewedToken(renewed);
+			return res.user;
+		}));
+	}
+	loginWithGoogle() {
+		if (!this.firebaseAdapter) return throwError(() => /* @__PURE__ */ new Error("[gas-admin-ui] FIREBASE_AUTH_ADAPTER is not provided."));
+		return from(this.firebaseAdapter.signInWithGoogle()).pipe(switchMap((idToken) => this.exchangeFirebaseToken(idToken)));
+	}
+	loginWithFirebasePassword(email, password) {
+		if (!this.firebaseAdapter) return throwError(() => /* @__PURE__ */ new Error("[gas-admin-ui] FIREBASE_AUTH_ADAPTER is not provided."));
+		return from(this.firebaseAdapter.signInWithEmailAndPassword(email, password)).pipe(switchMap((idToken) => this.exchangeFirebaseToken(idToken)));
+	}
+	exchangeFirebaseToken(idToken) {
+		const endpoint = getAuth()?.firebase?.exchangeEndpoint ?? "/auth/firebase";
+		return this.post(endpoint, { idToken }).pipe(map((res) => {
+			this.open(res.token, res.user);
+			const renewed = renewedTokenOf(res);
+			if (renewed !== null) this.applyRenewedToken(renewed);
+			return res.user;
+		}));
+	}
+	logout() {
+		return this.post("/auth/logout").pipe(tap({
+			next: () => {
+				this.clear();
+				this.firebaseAdapter?.signOut();
+				this.goLogin();
+			},
+			error: () => {
+				this.clear();
+				this.firebaseAdapter?.signOut();
+				this.goLogin();
+			}
+		}), map(() => void 0));
+	}
+	restore() {
+		if (this._token() === null) return of(void 0);
+		return this.post("/auth/me").pipe(tap((res) => {
+			this.open(this._token(), res.user);
+		}), catchError(() => of(void 0)), map(() => void 0));
+	}
+	applyRenewedToken(token) {
+		if (token === "" || this._token() === null) return;
+		this._token.set(token);
+		this.storage.setItem(SESSION_TOKEN_KEY, token);
+	}
+	applyAuthCode(code) {
+		switch (code) {
+			case "AUTH_EXPIRED":
+				this._returnUrl.set(this.currentUrl());
+				this.clear();
+				this.goLogin();
+				break;
+			case "AUTH_REQUIRED":
+			case "AUTH_INVALID":
+				this.clear();
+				this.goLogin();
+		}
+	}
+	hasRole(required) {
+		if (required === "" || required === "session") return this.isAuthenticated();
+		const role = this.role();
+		if (role === "admin") return true;
+		return role !== "" && role === required;
+	}
+	canAccess(access) {
+		const requires = access?.requires ?? "session";
+		if (requires === "public") return true;
+		if (!this.isAuthenticated()) return false;
+		const role = requires.startsWith("role:") ? requires.slice(5) : "";
+		const required = role === "" ? access?.roles ?? [] : [role];
+		if (required.length === 0) return true;
+		return required.some((one) => this.hasRole(one));
+	}
+	canDoOperation(schema, operation) {
+		if (operation === "create" || operation === "update" || operation === "remove") {
+			const ep = schema.endpoint;
+			if (!!ep && Object.keys(ep).length > 0 && !ep[operation]) return false;
+		}
+		const ops = schema.policies?.access?.operations;
+		if (ops && ops[operation]) return this.meetsLevel(ops[operation]);
+		if (schema.policies?.access) {
+			const groupLevel = operation === "create" || operation === "update" || operation === "remove" ? schema.policies.access.write : schema.policies.access.read;
+			return this.meetsLevel(groupLevel ?? "admin");
+		}
+		const perms = schema.permissions;
+		if (perms) return {
+			list: true,
+			get: true,
+			create: perms.create,
+			update: perms.update,
+			remove: perms.remove
+		}[operation] !== false;
+		return true;
+	}
+	canReadField(field) {
+		if (!field.access || !field.access.read) return true;
+		return this.meetsLevel(field.access.read);
+	}
+	canWriteField(field) {
+		if (!field.access || !field.access.write) return true;
+		return this.meetsLevel(field.access.write);
+	}
+	meetsLevel(level) {
+		if (level === "public") return true;
+		if (level === "session") return this.isAuthenticated();
+		if (level.startsWith("role:")) {
+			const requiredRole = level.slice(5);
+			return this.hasRole(requiredRole);
+		}
+		return this.hasRole("admin");
+	}
+	open(token, user) {
+		if (token !== null && token !== "") this._token.set(token);
+		this._user.set(user);
+		if (token !== null && token !== "") this.storage.setItem(SESSION_TOKEN_KEY, token);
+		if (user !== null) this.storage.setItem(SESSION_USER_KEY, JSON.stringify(user));
+	}
+	consumeReturnUrl() {
+		const url = this._returnUrl();
+		this._returnUrl.set(null);
+		return url;
+	}
+	clear() {
+		this._token.set(null);
+		this._user.set(null);
+		this.storage.removeItem(SESSION_TOKEN_KEY);
+		this.storage.removeItem(SESSION_USER_KEY);
+	}
+	goLogin() {
+		if (this.currentUrl().startsWith("/login")) return;
+		this.router.navigate([LOGIN_PATH]).catch(() => void 0);
+	}
+	currentUrl() {
+		return this.router.url;
+	}
+	buildUrl(path) {
+		return `${this.apiUrl ? this.apiUrl.replace(/\/+$/, "") : ""}${path.startsWith("/") ? path : `/${path}`}`;
+	}
+	envelope(path, payload = {}) {
+		return {
+			token: this._token(),
+			method: "POST",
+			path,
+			payload
+		};
+	}
+	buildAuthRequest(path, payload = {}) {
+		if (this.driver === "rest") {
+			const url = this.buildUrl(path);
+			let headers = new HttpHeaders();
+			const token = this._token();
+			if (token) headers = headers.set("Authorization", `Bearer ${token}`);
+			if (path === "/auth/me") return this.http.get(url, { headers });
+			headers = headers.set("Content-Type", "application/json");
+			return this.http.post(url, payload, { headers });
+		}
+		return this.http.post(this.apiUrl, this.envelope(path, payload), { headers: { "Content-Type": "text/plain" } });
+	}
+	post(path, payload = {}) {
+		return this.buildAuthRequest(path, payload).pipe(map((res) => res && typeof res === "object" && !Array.isArray(res) && "data" in res ? res["data"] : res));
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: AuthService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: AuthService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: AuthService,
+	decorators: [{ type: Service }],
+	ctorParameters: () => []
+});
+function httpMessage(status) {
+	switch (status) {
+		case 0: return "No se pudo conectar con el servidor. Revisa tu conexión.";
+		case 401: return "Tu sesión ha expirado. Vuelve a iniciar sesión.";
+		case 403: return "No tienes permisos para realizar esta acción.";
+		case 404: return "No se encontró el recurso solicitado.";
+		case 409: return "El registro cambió o ya existe. Recarga la página y vuelve a intentarlo.";
+		case 413: return "El archivo es demasiado grande.";
+		case 422: return "Los datos enviados no son válidos.";
+		default:
+			if (status >= 500) return "El servidor tuvo un problema. Vuelve a intentarlo en unos segundos.";
+			return status >= 400 ? "No se pudo completar la operación." : "Error inesperado.";
+	}
+}
+function isErrorBody(body) {
+	if (typeof body !== "object" || body === null) return false;
+	const error = body.error;
+	return typeof error === "object" && error !== null && typeof error.message === "string";
+}
+const apiErrorInterceptor = (req, next) => {
+	const auth = inject(AuthService);
+	return next(req).pipe(map((event) => {
+		if (event instanceof HttpResponse && isErrorBody(event.body)) {
+			const { status, message, path, code, errors } = event.body.error;
+			auth.applyAuthCode(code);
+			throw new ApiError(status, message, path, code, errors ?? []);
+		}
+		return event;
+	}), catchError((err) => {
+		if (err instanceof ApiError) return throwError(() => err);
+		if (err instanceof HttpErrorResponse) return throwError(() => new ApiError(err.status, httpMessage(err.status)));
+		return throwError(() => err);
+	}));
+};
+function appliesTo(unwrap, operation) {
+	const apply = unwrap.apply ?? "all";
+	return apply === "all" || apply === operation;
+}
+function unwrapResponse(raw, unwrap, operation) {
+	if (!unwrap || !appliesTo(unwrap, operation)) return raw;
+	if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+		const record = raw;
+		if (Object.prototype.hasOwnProperty.call(record, unwrap.dataKey)) return record[unwrap.dataKey];
+	}
+	throw new Error(`Response unwrap declared dataKey '${unwrap.dataKey}' but it is missing in the response for operation '${operation}'`);
+}
+const NO_PAGINATION = {
+	nextCursor: null,
+	total: 0,
+	hasMore: false
+};
+function extractPagination(raw, unwrap) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return { ...NO_PAGINATION };
+	const body = raw;
+	let source = body;
+	const metaKey = unwrap?.metaKey;
+	if (metaKey) {
+		const meta = body[metaKey];
+		if (meta !== null && typeof meta === "object" && !Array.isArray(meta)) source = meta;
+	}
+	const cursorKey = unwrap?.pagination?.cursorKey ?? "nextCursor";
+	const totalKey = unwrap?.pagination?.totalKey ?? "total";
+	const hasMoreKey = unwrap?.pagination?.hasMoreKey ?? "hasMore";
+	const cursorValue = source[cursorKey] ?? body[cursorKey];
+	const nextCursor = typeof cursorValue === "string" && cursorValue !== "" ? cursorValue : null;
+	const totalValue = source[totalKey] ?? body[totalKey];
+	const total = typeof totalValue === "number" ? totalValue : 0;
+	const hasMoreValue = source[hasMoreKey] ?? body[hasMoreKey];
+	return {
+		nextCursor,
+		total,
+		hasMore: typeof hasMoreValue === "boolean" ? hasMoreValue : nextCursor !== null
+	};
+}
+const MARKER = /\{([a-zA-Z0-9_.]+)\}/g;
+function resolveEndpointPath(path, sources) {
+	if (!path.includes("{")) return path;
+	return path.replace(MARKER, (marker, nombre) => sustituir(path, marker, nombre, sources));
+}
+function sustituir(path, marker, nombre, sources) {
+	if (nombre === "key") throw new Error(`[gas-admin-ui] path '${path}': ${marker} llegó sin resolver — la clave sólo la sustituyen get/update/remove antes de resolver el contexto.`);
+	const punto = nombre.indexOf(".");
+	const fuente = punto === -1 ? nombre : nombre.slice(0, punto);
+	const getter = sources[fuente];
+	if (typeof getter !== "function") throw new Error(`[gas-admin-ui] path '${path}': no se pudo resolver ${marker} — la fuente '${fuente}' no está registrada.`);
+	const valor = punto === -1 ? getter() : leerRuta(getter(), nombre.slice(punto + 1));
+	if (valor === void 0 || valor === null) throw new Error(`[gas-admin-ui] path '${path}': no se pudo resolver ${marker} — sin valor para '${nombre}'.`);
+	if (typeof valor === "object") throw new Error(`[gas-admin-ui] path '${path}': no se pudo resolver ${marker} — el valor de '${fuente}' no es un segmento de URL (no es escalar).`);
+	const texto = String(valor);
+	if (texto === "") throw new Error(`[gas-admin-ui] path '${path}': no se pudo resolver ${marker} — valor vacío en '${fuente}'.`);
+	return encodeURIComponent(texto);
+}
+function leerRuta(valor, ruta) {
+	let actual = valor;
+	for (const paso of ruta.split(".")) {
+		if (actual === null || typeof actual !== "object") return void 0;
+		actual = actual[paso];
+	}
+	return actual;
+}
+function sendGas(deps, path, method, payload, multipart = false) {
+	if (multipart) throw new Error("Multipart payload mode is only supported with the REST driver");
+	const body = {
+		token: deps.sessionToken(),
+		method,
+		path,
+		payload: payload ?? {}
+	};
+	return deps.http.post(deps.apiUrl, body, { headers: { "Content-Type": "text/plain" } });
+}
+function sendRest(deps, path, method, payload, multipart = false) {
+	const url = buildUrl(deps.apiUrl, path);
+	const headers = new HttpHeaders();
+	if (deps.getIdToken) return from(deps.getIdToken()).pipe(switchMap((freshToken) => doRestRequest(deps, url, method, payload, headers.set("Authorization", `Bearer ${freshToken}`), multipart)));
+	const token = deps.sessionToken();
+	return doRestRequest(deps, url, method, payload, token ? headers.set("Authorization", `Bearer ${token}`) : headers, multipart);
+}
+function doRestRequest(deps, url, method, payload, headers = new HttpHeaders(), multipart = false) {
+	if (method === "GET" || method === "DELETE") {
+		const params = toHttpParams(payload instanceof FormData ? void 0 : payload);
+		return deps.http.request(method, url, {
+			headers,
+			params
+		});
+	}
+	if (multipart || payload instanceof FormData) return deps.http.request(method, url, {
+		headers,
+		body: payload ?? {}
+	});
+	return deps.http.request(method, url, {
+		headers: headers.set("Content-Type", "application/json"),
+		body: payload ?? {}
+	});
+}
+function buildUrl(apiUrl, path) {
+	return `${apiUrl ? apiUrl.replace(/\/+$/, "") : ""}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function toHttpParams(payload) {
+	let params = new HttpParams();
+	if (!payload) return params;
+	for (const [key, value] of Object.entries(payload)) {
+		if (value === void 0 || value === null) continue;
+		if (typeof value === "object" && !Array.isArray(value)) {
+			for (const [nestedKey, nestedValue] of Object.entries(value)) if (nestedValue !== void 0 && nestedValue !== null) params = params.set(nestedKey, String(nestedValue));
+		} else if (Array.isArray(value)) {
+			for (const item of value) if (item !== void 0 && item !== null) params = params.append(key, String(item));
+		} else params = params.set(key, String(value));
+	}
+	return params;
+}
+var ApiService = class ApiService {
+	http = inject(HttpClient);
+	apiUrl = inject(API_URL);
+	auth = inject(AuthService);
+	driver = inject(API_DRIVER, { optional: true }) ?? "gas";
+	valueSources = inject(VALUE_SOURCES, { optional: true }) ?? {};
+	firebaseAuthAdapter = inject(FIREBASE_AUTH_ADAPTER, { optional: true });
+	injector = inject(Injector);
+	defaultUnwrap = inject(DEFAULT_RESPONSE_UNWRAP, { optional: true }) ?? void 0;
+	effectiveUnwrap(endpoint) {
+		const global = this.defaultUnwrap;
+		const local = endpoint.responseUnwrap;
+		if (!global) return local;
+		if (!local) return global;
+		return {
+			...global,
+			...local
+		};
+	}
+	list(endpoint, payload) {
+		const unwrap = this.effectiveUnwrap(endpoint);
+		return this.send(endpoint.list, "GET", payload).pipe(map((raw) => {
+			if (unwrap && (unwrap.apply === "list" || unwrap.apply === "all" || !unwrap.apply)) return unwrapResponse(raw, unwrap, "list");
+			return unwrapList(raw);
+		}));
+	}
+	listPage(endpoint, payload) {
+		const unwrap = this.effectiveUnwrap(endpoint);
+		const applies = !unwrap || unwrap.apply === "list" || unwrap.apply === "all" || !unwrap.apply;
+		return this.send(endpoint.list, "GET", payload).pipe(map((raw) => {
+			return {
+				items: unwrap && applies ? unwrapResponse(raw, unwrap, "list") : unwrapList(raw),
+				...extractPagination(raw, unwrap)
+			};
+		}));
+	}
+	get(endpoint, key) {
+		const unwrap = this.effectiveUnwrap(endpoint);
+		return this.send(this.withKey(endpoint.get, key), "GET").pipe(map((raw) => {
+			if (unwrap && (unwrap.apply === "get" || unwrap.apply === "all" || !unwrap.apply)) return unwrapResponse(raw, unwrap, "get");
+			return raw;
+		}));
+	}
+	create(endpoint, payload) {
+		const unwrap = this.effectiveUnwrap(endpoint);
+		return this.send(endpoint.create, "POST", payload).pipe(map((raw) => {
+			if (unwrap && (unwrap.apply === "create" || unwrap.apply === "all" || !unwrap.apply)) return unwrapResponse(raw, unwrap, "create");
+			return raw;
+		}));
+	}
+	update(endpoint, key, payload) {
+		const unwrap = this.effectiveUnwrap(endpoint);
+		return this.send(this.withKey(endpoint.update, key), "PUT", payload).pipe(map((raw) => {
+			if (unwrap && (unwrap.apply === "update" || unwrap.apply === "all" || !unwrap.apply)) return unwrapResponse(raw, unwrap, "update");
+			return raw;
+		}));
+	}
+	remove(endpoint, key) {
+		endpoint.responseUnwrap;
+		return this.send(this.withKey(endpoint.remove, key), "DELETE").pipe(map(() => void 0));
+	}
+	request(method, path, payload) {
+		const dataKey = this.defaultUnwrap?.dataKey ?? "data";
+		return this.send(path, method, payload).pipe(map((raw) => {
+			if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+				const rec = raw;
+				if (Object.prototype.hasOwnProperty.call(rec, dataKey)) return rec[dataKey];
+			}
+			return raw;
+		}));
+	}
+	invokeCustomEndpoint(definitionOrSchema, nameOrPayload, payload, key) {
+		let definition;
+		let actualPayload;
+		let actualKey = key;
+		if (isResourceSchema(definitionOrSchema)) {
+			const name = typeof nameOrPayload === "string" ? nameOrPayload : void 0;
+			if (!name) throw new Error("invokeCustomEndpoint requires an endpoint name when given a schema");
+			definition = definitionOrSchema.customEndpoints?.[name];
+			if (!definition) throw new Error(`Custom endpoint '${name}' is not declared for resource '${definitionOrSchema.id}'`);
+			actualPayload = (typeof nameOrPayload === "string" ? payload : nameOrPayload) ?? payload;
+		} else {
+			definition = definitionOrSchema;
+			actualPayload = nameOrPayload ?? payload;
+		}
+		if (!definition) return throwError(() => /* @__PURE__ */ new Error("Custom endpoint definition is required"));
+		const multipart = definition.payloadMode === "multipart" || actualPayload instanceof FormData;
+		const path = this.withKey(definition.path, actualKey);
+		const method = definition.method;
+		const unwrap = definition.responseUnwrap;
+		return this.send(path, method, actualPayload, multipart).pipe(map((raw) => {
+			if (unwrap) return unwrapResponse(raw, unwrap, "get");
+			return raw;
+		}));
+	}
+	invokeCustom(schemaOrDefinition, nameOrPayload, payload, key) {
+		return this.invokeCustomEndpoint(schemaOrDefinition, nameOrPayload, payload, key);
+	}
+	custom(schemaOrDefinition, nameOrPayload, payload, key) {
+		return this.invokeCustomEndpoint(schemaOrDefinition, nameOrPayload, payload, key);
+	}
+	send(path, method, payload, multipart = false) {
+		if (!path) return throwError(() => /* @__PURE__ */ new Error("Operación no disponible para este recurso"));
+		let resolvedPath;
+		try {
+			resolvedPath = resolveEndpointPath(path, this.buildSources());
+		} catch (error) {
+			return throwError(() => error);
+		}
+		const deps = this.transportDeps();
+		return (this.driver === "rest" ? sendRest(deps, resolvedPath, method, payload, multipart) : sendGas(deps, resolvedPath, method, payload, multipart)).pipe(tap((res) => {
+			const renewed = renewedTokenOf(res);
+			if (renewed !== null) this.auth.applyRenewedToken(renewed);
+		}));
+	}
+	transportDeps() {
+		const adapter = this.firebaseAuthAdapter;
+		return {
+			http: this.http,
+			apiUrl: this.apiUrl,
+			sessionToken: () => this.auth.token(),
+			getIdToken: adapter?.getIdToken ? () => adapter.getIdToken() : void 0
+		};
+	}
+	buildSources() {
+		return {
+			...this.valueSources,
+			auth: () => ({
+				user: this.auth.user(),
+				token: this.auth.token()
+			}),
+			config: () => this.injector.get(ConfigService, null)?.globalConfig() ?? null
+		};
+	}
+	withKey(path, key) {
+		if (!path) return;
+		return path.includes("{key}") ? path.replace("{key}", encodeURIComponent(key ?? "")) : path;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: ApiService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: ApiService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: ApiService,
+	decorators: [{ type: Service }]
+});
+function isResourceSchema(value) {
+	return typeof value === "object" && value !== null && "endpoint" in value && "fields" in value;
+}
+function unwrapList(raw) {
+	if (Array.isArray(raw)) return raw;
+	if (raw !== null && typeof raw === "object") {
+		const items = raw.items;
+		if (Array.isArray(items)) return items;
+		return [];
+	}
+	throw new Error(`List response must be an array or an object with an 'items' array; received ${raw === null ? "null" : typeof raw}`);
+}
+var ConfigService = class ConfigService {
+	api = inject(ApiService, { optional: true });
+	globalConfig = signal({ public_base_url: typeof window !== "undefined" ? window.location.origin : "" }, ...ngDevMode ? [{ debugName: "globalConfig" }] : /* istanbul ignore next */ []);
+	endpoints = [];
+	loaded = false;
+	inFlight = null;
+	load(endpoints) {
+		this.endpoints = endpoints;
+		this.ensure();
+	}
+	ensureLoaded() {
+		return this.ensure();
+	}
+	ensure() {
+		if (this.loaded) return Promise.resolve();
+		if (this.inFlight) return this.inFlight;
+		if (!this.api || typeof this.api.get !== "function" || this.endpoints.length === 0) return Promise.resolve();
+		this.inFlight = firstValueFrom(forkJoin(this.endpoints.map((endpoint) => this.api.get(endpoint).pipe(catchError(() => of(null)))))).then((blocks) => {
+			this.inFlight = null;
+			blocks.forEach((data) => {
+				if (data && typeof data === "object" && Object.keys(data).length > 0) this.globalConfig.update((current) => ({
+					...current,
+					...data
+				}));
+			});
+			this.loaded = blocks.every((data) => data !== null);
+		});
+		return this.inFlight;
+	}
+	buildInterpolationContext(record) {
+		const config = this.globalConfig();
+		const baseUrl = String(config["public_base_url"] || window.location.origin).replace(/\/+$/, "");
+		return {
+			...config,
+			...record,
+			public_base_url: baseUrl
+		};
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: ConfigService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.3",
+		ngImport: i0,
+		type: ConfigService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: ConfigService,
+	decorators: [{ type: Service }]
+});
+let catalog = [];
+let authCatalog;
+function setSchemaCatalog(schemas, auth) {
+	catalog = schemas;
+	authCatalog = auth;
+}
+function getSchema(id) {
+	return catalog.find((schema) => schema.id === id);
+}
+function allSchemas() {
+	return catalog;
+}
+function getAuth() {
+	return authCatalog;
+}
+const GAS_SCHEMAS = new InjectionToken("gas.admin.schemas");
+function provideGasAdmin(config) {
+	setSchemaCatalog(config.schemas, config.auth);
+	const configEndpoints = () => config.schemas.flatMap((schema) => schema.kind === "singleton" && schema.endpoint?.get ? [{ get: schema.endpoint.get }] : []);
+	return [
+		{
+			provide: GAS_SCHEMAS,
+			useValue: config.schemas
+		},
+		{
+			provide: API_DRIVER,
+			useValue: config.driver ?? "gas"
+		},
+		{
+			provide: VALUE_SOURCES,
+			useValue: config.valueSources ?? {}
+		},
+		{
+			provide: DEFAULT_RESPONSE_UNWRAP,
+			useValue: config.defaultResponseUnwrap
+		},
+		provideHttpClient(withInterceptors([apiErrorInterceptor])),
+		provideAppInitializer(() => inject(ConfigService).load(configEndpoints())),
+		provideAppInitializer(() => inject(AuthService).restore())
+	];
+}
+function provideFirebaseAdapter(adapter) {
+	return {
+		provide: FIREBASE_AUTH_ADAPTER,
+		useValue: adapter
+	};
+}
+export { DEFAULT_RESPONSE_UNWRAP as _, provideFirebaseAdapter as a, ApiError as b, ConfigService as c, AuthService as d, LOGIN_PATH as f, API_URL as g, API_DRIVER as h, getSchema as i, ApiService as l, SESSION_USER_KEY as m, allSchemas as n, provideGasAdmin as o, SESSION_TOKEN_KEY as p, getAuth as r, setSchemaCatalog as s, GAS_SCHEMAS as t, apiErrorInterceptor as u, FIREBASE_AUTH_ADAPTER as v, renewedTokenOf as x, VALUE_SOURCES as y };
+
+//# sourceMappingURL=tinya-code-gas-admin-ui-schema-catalog-D0Pk0wAN.mjs.map