@oktis-works/admin 0.1.3 → 0.1.5

package/dist/server/chunks/api_Cy8sbUHf.mjs

@@ -0,0 +1,153 @@
+//#region src/lib/api.ts
+var API_BASE = Object.assign({
+	"ASSETS_PREFIX": void 0,
+	"BASE_URL": "/",
+	"DEV": false,
+	"MODE": "production",
+	"PROD": true,
+	"SITE": void 0,
+	"SSR": true
+}, { _: "/home/runner/work/cms/cms/apps/admin/node_modules/.bin/astro" })["PUBLIC_API_URL"] ?? "http://localhost:3000";
+var ApiClient = class {
+	baseUrl;
+	accessToken = null;
+	refreshTokenValue = null;
+	constructor(baseUrl = API_BASE) {
+		this.baseUrl = baseUrl;
+	}
+	setTokens(accessToken, refreshToken) {
+		this.accessToken = accessToken;
+		this.refreshTokenValue = refreshToken;
+		if (typeof window !== "undefined") {
+			localStorage.setItem("accessToken", accessToken);
+			localStorage.setItem("refreshToken", refreshToken);
+		}
+	}
+	loadTokens() {
+		if (typeof window !== "undefined") {
+			this.accessToken = localStorage.getItem("accessToken");
+			this.refreshTokenValue = localStorage.getItem("refreshToken");
+		}
+	}
+	clearTokens() {
+		this.accessToken = null;
+		this.refreshTokenValue = null;
+		if (typeof window !== "undefined") {
+			localStorage.removeItem("accessToken");
+			localStorage.removeItem("refreshToken");
+		}
+	}
+	async request(method, path, body, headers) {
+		const url = `${this.baseUrl}${path}`;
+		const requestHeaders = {
+			"Content-Type": "application/json",
+			...headers
+		};
+		if (this.accessToken) requestHeaders["Authorization"] = `Bearer ${this.accessToken}`;
+		const response = await fetch(url, {
+			method,
+			headers: requestHeaders,
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (!response.ok) {
+			const error = await response.json().catch(() => ({ error: "Request failed" }));
+			throw new Error(error.error ?? "Request failed");
+		}
+		return response.json();
+	}
+	async login(input) {
+		const response = await this.request("POST", "/api/v1/auth/login", input);
+		this.setTokens(response.accessToken, response.refreshToken);
+		return response;
+	}
+	async logout() {
+		if (this.refreshTokenValue) await this.request("POST", "/api/v1/auth/logout", { token: this.refreshTokenValue });
+		this.clearTokens();
+	}
+	async refreshTokens() {
+		if (!this.refreshTokenValue) throw new Error("No refresh token");
+		const response = await this.request("POST", "/api/v1/auth/refresh", { refreshToken: this.refreshTokenValue });
+		this.setTokens(response.accessToken, response.refreshToken);
+	}
+	async getContent(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.type) params.set("type", options.type);
+		if (options?.status) params.set("status", options.status);
+		if (options?.search) params.set("search", options.search);
+		return this.request("GET", `/api/v1/content?${params.toString()}`);
+	}
+	async getContentById(id) {
+		return this.request("GET", `/api/v1/content/${id}`);
+	}
+	async createContent(data) {
+		return this.request("POST", "/api/v1/content", data);
+	}
+	async updateContent(id, data) {
+		return this.request("PUT", `/api/v1/content/${id}`, data);
+	}
+	async deleteContent(id) {
+		await this.request("DELETE", `/api/v1/content/${id}`);
+	}
+	async getContentTypes() {
+		return this.request("GET", "/api/v1/content-types");
+	}
+	async createContentType(data) {
+		return this.request("POST", "/api/v1/content-types", data);
+	}
+	async updateContentType(slug, data) {
+		return this.request("PUT", `/api/v1/content-types/${slug}`, data);
+	}
+	async deleteContentType(slug) {
+		await this.request("DELETE", `/api/v1/content-types/${slug}`);
+	}
+	async getTaxonomies() {
+		return this.request("GET", "/api/v1/taxonomies");
+	}
+	async createTaxonomy(data) {
+		return this.request("POST", "/api/v1/taxonomies", data);
+	}
+	async attachTaxonomy(slug, contentType) {
+		await this.request("POST", `/api/v1/taxonomies/${slug}/attach`, { contentType });
+	}
+	async detachTaxonomy(slug, contentType) {
+		await this.request("POST", `/api/v1/taxonomies/${slug}/detach`, { contentType });
+	}
+	async deleteTaxonomy(slug) {
+		await this.request("DELETE", `/api/v1/taxonomies/${slug}`);
+	}
+	async getFieldGroups(context) {
+		if (context?.type) {
+			const qs = new URLSearchParams({ type: context.type });
+			for (const [key, value] of Object.entries(context)) if (key !== "type" && value) qs.set(key, value);
+			return this.request("GET", `/api/v1/field-groups?${qs.toString()}`);
+		}
+		return this.request("GET", "/api/v1/field-groups");
+	}
+	async getFieldGroup(id) {
+		return this.request("GET", `/api/v1/field-groups/${id}`);
+	}
+	async createFieldGroup(data) {
+		return this.request("POST", "/api/v1/field-groups", data);
+	}
+	async getFieldTypes(category) {
+		const query = category ? `?category=${encodeURIComponent(category)}` : "";
+		return this.request("GET", `/api/v1/field-types${query}`);
+	}
+	async healthCheck() {
+		return this.request("GET", "/health");
+	}
+	async getThemes() {
+		return (await this.request("GET", "/api/v1/themes")).map((theme) => ({
+			id: String(theme["id"] ?? ""),
+			name: String(theme["name"] ?? ""),
+			version: theme["version"] ? String(theme["version"]) : void 0,
+			status: String(theme["status"] ?? "INSTALLED"),
+			manifest: theme["manifest"] ?? null
+		}));
+	}
+};
+var apiClient = new ApiClient();
+//#endregion
+export { apiClient as t };

package/dist/server/chunks/compiler_CYjwXhLT.mjs

@@ -0,0 +1,35 @@
+import { t as AstroError, x as InvalidComponentArgs } from "./errors_mm28nMpQ.mjs";
+import "./server_CnzC2Y0K.mjs";
+//#region ../../node_modules/.bun/astro@7.3.5+b816f5dfb7c6296d/node_modules/astro/dist/runtime/server/astro-component.js
+function validateArgs(args) {
+	if (args.length !== 3) return false;
+	if (!args[0] || typeof args[0] !== "object") return false;
+	return true;
+}
+function baseCreateComponent(cb, moduleId, propagation) {
+	const name = moduleId?.split("/").pop()?.replace(".astro", "") ?? "";
+	const fn = (...args) => {
+		if (!validateArgs(args)) throw new AstroError({
+			...InvalidComponentArgs,
+			message: InvalidComponentArgs.message(name)
+		});
+		return cb(...args);
+	};
+	Object.defineProperty(fn, "name", {
+		value: name,
+		writable: false
+	});
+	fn.isAstroComponentFactory = true;
+	fn.moduleId = moduleId;
+	fn.propagation = propagation;
+	return fn;
+}
+function createComponentWithOptions(opts) {
+	return baseCreateComponent(opts.factory, opts.moduleId, opts.propagation);
+}
+function createComponent(arg1, moduleId, propagation) {
+	if (typeof arg1 === "function") return baseCreateComponent(arg1, moduleId, propagation);
+	else return createComponentWithOptions(arg1);
+}
+//#endregion
+export { createComponent as t };

package/dist/server/chunks/console_tZnymcoE.mjs

@@ -0,0 +1,170 @@
+import { T as s } from "./server_CnzC2Y0K.mjs";
+//#region ../../node_modules/.bun/astro@7.3.5+b816f5dfb7c6296d/node_modules/astro/dist/core/logger/core.js
+var dateTimeFormat = new Intl.DateTimeFormat([], {
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false
+});
+var levels = {
+	debug: 20,
+	info: 30,
+	warn: 40,
+	error: 50,
+	silent: 90
+};
+function log(opts, level, label, message, newLine = true) {
+	const logLevel = opts.level;
+	const dest = opts.destination;
+	const event = {
+		label,
+		level,
+		message,
+		newLine
+	};
+	if (!isLogLevelEnabled(logLevel, level)) return;
+	dest.write(event);
+}
+function isLogLevelEnabled(configuredLogLevel, level) {
+	return levels[configuredLogLevel] <= levels[level];
+}
+function info(opts, label, message, newLine = true) {
+	return log(opts, "info", label, message, newLine);
+}
+function warn(opts, label, message, newLine = true) {
+	return log(opts, "warn", label, message, newLine);
+}
+function error(opts, label, message, newLine = true) {
+	return log(opts, "error", label, message, newLine);
+}
+function debug(...args) {
+	if ("_astroGlobalDebug" in globalThis) globalThis._astroGlobalDebug(...args);
+}
+function getEventPrefix({ level, label }) {
+	const timestamp = `${dateTimeFormat.format(/* @__PURE__ */ new Date())}`;
+	const prefix = [];
+	if (level === "error" || level === "warn") {
+		prefix.push(s.bold(timestamp));
+		prefix.push(`[${level.toUpperCase()}]`);
+	} else prefix.push(timestamp);
+	if (label) prefix.push(`[${label}]`);
+	if (level === "error") return s.red(prefix.join(" "));
+	if (level === "warn") return s.yellow(prefix.join(" "));
+	if (prefix.length === 1) return s.dim(prefix[0]);
+	return s.dim(prefix[0]) + " " + s.blue(prefix.splice(1).join(" "));
+}
+var AstroLogger = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	info(label, message, newLine = true) {
+		info(this.options, label, message, newLine);
+	}
+	warn(label, message, newLine = true) {
+		warn(this.options, label, message, newLine);
+	}
+	error(label, message, newLine = true) {
+		error(this.options, label, message, newLine);
+	}
+	debug(label, ...messages) {
+		debug(label, ...messages);
+	}
+	level() {
+		return this.options.level;
+	}
+	forkIntegrationLogger(label) {
+		return new AstroIntegrationLogger(this.options, label);
+	}
+	setDestination(destination) {
+		this.options.destination = destination;
+	}
+	/**
+	* It calls the `close` function of the provided destination, if it exists.
+	*/
+	close() {
+		if (this.options.destination.close) this.options.destination.close();
+	}
+	/**
+	* It calls the `flush` function of the provided destination, if it exists.
+	*/
+	flush() {
+		if (this.options.destination.flush) this.options.destination.flush();
+	}
+};
+var AstroIntegrationLogger = class AstroIntegrationLogger {
+	options;
+	label;
+	constructor(logging, label) {
+		this.options = logging;
+		this.label = label;
+	}
+	/**
+	* Creates a new logger instance with a new label, but the same log options.
+	*/
+	fork(label) {
+		return new AstroIntegrationLogger(this.options, label);
+	}
+	info(message) {
+		info(this.options, this.label, message);
+	}
+	warn(message) {
+		warn(this.options, this.label, message);
+	}
+	error(message) {
+		error(this.options, this.label, message);
+	}
+	debug(message) {
+		debug(this.label, message);
+	}
+	/**
+	* It calls the `flush` function of the provided destination, if it exists.
+	*/
+	flush() {
+		if (this.options.destination.flush) this.options.destination.flush();
+	}
+	/**
+	* It calls the `close` function of the provided destination, if it exists.
+	*/
+	close() {
+		if (this.options.destination.close) this.options.destination.close();
+	}
+};
+function astroToRuntimeLogger(logger) {
+	return {
+		info(msg) {
+			logger.info(null, msg);
+		},
+		warn(msg) {
+			logger.warn(null, msg);
+		},
+		error(msg) {
+			logger.error(null, msg);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/astro@7.3.5+b816f5dfb7c6296d/node_modules/astro/dist/core/logger/public.js
+function matchesLevel(messageLevel, configuredLevel) {
+	return levels[messageLevel] >= levels[configuredLevel];
+}
+//#endregion
+//#region ../../node_modules/.bun/astro@7.3.5+b816f5dfb7c6296d/node_modules/astro/dist/core/logger/impls/console.js
+function consoleLogDestination(config = {}) {
+	const { level = "info" } = config;
+	return { write(event) {
+		let dest = console.error;
+		if (levels[event.level] < levels["error"]) dest = console.info;
+		if (!matchesLevel(event.level, level)) return;
+		if (event.label === "SKIP_FORMAT") dest(event.message);
+		else dest(getEventPrefix(event) + " " + event.message);
+	} };
+}
+function createConsoleLogger({ level }) {
+	return new AstroLogger({
+		level,
+		destination: consoleLogDestination()
+	});
+}
+//#endregion
+export { AstroIntegrationLogger as n, astroToRuntimeLogger as r, createConsoleLogger as t };