@stephenchenorg/astro 5.0.2 → 6.1.0

package/dist/api/index.d.ts

@@ -1,3 +1,76 @@
-export * from './error';
-export * from './errorResponse';
-export * from './fetch';
+import { gql } from "graphql-tag";
+import { TypedDocumentNode } from "@graphql-typed-document-node/core";
+import { APIContext } from "astro";
+
+//#region src/api/error.d.ts
+interface GraphQLFieldError {
+  code?: number;
+  message: string;
+  locations?: {
+    line: number;
+    column: number;
+  }[];
+  path?: (string | number)[];
+  extensions?: GraphQLRequestExtensions;
+  data?: Record<string, any>;
+}
+interface GraphQLRequestExtensions {
+  debugMessage?: string;
+  file?: string;
+  line?: number;
+  trace?: {
+    file: string;
+    line: number;
+    call: number;
+  }[];
+}
+interface GraphQLRequestErrorOptions {
+  code?: number;
+  message: string;
+  query: string;
+  variables?: Record<string, any>;
+  extensions?: GraphQLRequestExtensions;
+  fieldErrors?: GraphQLFieldError[];
+}
+declare class GraphQLRequestError extends Error {
+  type: string;
+  name: string;
+  title: string;
+  code: number | undefined;
+  originalMessage: string;
+  query: string;
+  variables: Record<string, any> | undefined;
+  extensions: GraphQLRequestExtensions | undefined;
+  fieldErrors: GraphQLFieldError[] | undefined;
+  constructor(props: GraphQLRequestErrorOptions, options?: ErrorOptions);
+  isNotFound(): boolean;
+  private buildMessage;
+  static is(err: unknown): err is GraphQLRequestError;
+}
+declare class GraphQLNotFoundError extends GraphQLRequestError {
+  type: string;
+  name: string;
+}
+declare class GraphQLValidationError extends GraphQLRequestError {
+  type: string;
+  name: string;
+  errors: Record<string, string[]>;
+  constructor(props: GraphQLRequestErrorOptions, options?: ErrorOptions);
+}
+//#endregion
+//#region src/api/errorResponse.d.ts
+declare function handleErrorResponse(e: unknown): Response | undefined;
+//#endregion
+//#region src/api/fetch.d.ts
+interface CreateGraphQLAPIOptions {
+  endpoint: string;
+  defaultVariables?: Record<string, any> | ((astroContext?: APIContext) => Record<string, any>);
+  fetchOptions?: RequestInit | ((astroContext?: APIContext) => RequestInit);
+}
+declare function createGraphQLAPI(globalOptions: CreateGraphQLAPIOptions): <TData extends Record<string, any>, TVariables extends Record<string, any> = Record<string, any>>(query: TypedDocumentNode<TData, TVariables>, options?: {
+  variables?: TVariables;
+  fetchOptions?: RequestInit;
+  Astro?: APIContext;
+}) => Promise<TData>;
+//#endregion
+export { CreateGraphQLAPIOptions, GraphQLFieldError, GraphQLNotFoundError, GraphQLRequestError, GraphQLRequestErrorOptions, GraphQLRequestExtensions, GraphQLValidationError, createGraphQLAPI, gql, handleErrorResponse };

package/dist/api/index.js

@@ -1,3 +1,140 @@
-export * from "./error.js";
-export * from "./errorResponse.js";
-export * from "./fetch.js";
+import { AwesomeGraphQLClient, GraphQLRequestError as GraphQLRequestError$1 } from "awesome-graphql-client";
+import { print } from "graphql/language/printer";
+import { gql } from "graphql-tag";
+
+//#region src/api/error.ts
+var GraphQLRequestError = class extends Error {
+	type = "GraphQLRequestError";
+	name = "GraphQLRequestError";
+	title = "GraphQL request error.";
+	code;
+	originalMessage;
+	query;
+	variables;
+	extensions;
+	fieldErrors;
+	constructor(props, options) {
+		const { code, message, query, variables, extensions, fieldErrors } = props;
+		super("GraphQL request error.", options);
+		const originalStack = this.stack;
+		this.title = "GraphQL request error.";
+		this.code = code;
+		this.originalMessage = message;
+		this.query = query;
+		this.variables = variables;
+		this.extensions = extensions;
+		this.fieldErrors = fieldErrors;
+		this.message = this.buildMessage();
+		this.stack = originalStack;
+	}
+	isNotFound() {
+		return this.originalMessage.includes("Http Status 404");
+	}
+	buildMessage() {
+		let message = `${this.originalMessage}\n`;
+		if (this.code) {
+			message += "\n";
+			message += `[code]\n${this.code}\n`;
+		}
+		if (this.extensions) {
+			if (this.extensions.debugMessage) {
+				message += "\n";
+				message += `${this.extensions.debugMessage}\n`;
+			}
+			if (this.extensions.file || this.extensions.line || this.extensions.trace) {
+				message += "\n";
+				message += "[stacktrace]\n";
+				if (this.extensions.file) message += `file: ${this.extensions.file}\n`;
+				if (this.extensions.line) message += `line: ${this.extensions.line}\n`;
+				if (this.extensions.trace && Array.isArray(this.extensions.trace)) {
+					message += "trace:\n";
+					for (const trace of this.extensions.trace.slice(0, 3)) {
+						message += `  - file: ${trace.file}\n`;
+						message += `    line: ${trace.line}\n`;
+						message += `    call: ${trace.call}\n`;
+					}
+				}
+			}
+		}
+		if (this.query) {
+			message += "\n";
+			message += `[query]\n${this.query}\n`;
+		}
+		if (this.variables) {
+			message += "\n";
+			message += `[variables]\n${JSON.stringify(this.variables, null, 2)}\n`;
+		}
+		return message;
+	}
+	static is(err) {
+		return err.type === "GraphQLRequestError";
+	}
+};
+var GraphQLNotFoundError = class extends GraphQLRequestError {
+	type = "GraphQLNotFoundError";
+	name = "GraphQLNotFoundError";
+};
+var GraphQLValidationError = class extends GraphQLRequestError {
+	type = "GraphQLValidationError";
+	name = "GraphQLValidationError";
+	errors;
+	constructor(props, options) {
+		super(props, options);
+		this.errors = this.fieldErrors?.[0]?.data?.validation || {};
+	}
+};
+
+//#endregion
+//#region src/api/errorResponse.ts
+function handleErrorResponse(e) {
+	if (e instanceof GraphQLNotFoundError) return new Response(null, {
+		status: 404,
+		statusText: "Not found"
+	});
+}
+
+//#endregion
+//#region src/api/fetch.ts
+function createGraphQLAPI(globalOptions) {
+	const client = new AwesomeGraphQLClient({
+		endpoint: globalOptions.endpoint,
+		formatQuery: (query) => print(query)
+	});
+	return function graphQLAPI(query, options) {
+		const { variables, fetchOptions, Astro: astroContext } = options || {};
+		const defaultVariables = typeof globalOptions.defaultVariables === "function" ? globalOptions.defaultVariables(astroContext) : globalOptions.defaultVariables;
+		const defaultFetchOptions = typeof globalOptions.fetchOptions === "function" ? globalOptions.fetchOptions(astroContext) : globalOptions.fetchOptions;
+		return new Promise((resolve, reject) => {
+			client.request(query, {
+				...defaultVariables,
+				...variables
+			}, {
+				...defaultFetchOptions,
+				...fetchOptions,
+				headers: {
+					...defaultFetchOptions?.headers,
+					...fetchOptions?.headers
+				}
+			}).then((data) => resolve(data)).catch((error) => {
+				if (error instanceof GraphQLRequestError$1) {
+					const fieldError = error.fieldErrors?.[0];
+					const code = fieldError?.code;
+					const errorProps = {
+						code,
+						message: error.message,
+						query: error.query,
+						variables: error.variables,
+						extensions: error.extensions,
+						fieldErrors: error.fieldErrors
+					};
+					if (code === 404) reject(new GraphQLNotFoundError(errorProps));
+					else if (code === 422) reject(new GraphQLValidationError(errorProps));
+					reject(new GraphQLRequestError(errorProps));
+				} else reject(error);
+			});
+		});
+	};
+}
+
+//#endregion
+export { GraphQLNotFoundError, GraphQLRequestError, GraphQLValidationError, createGraphQLAPI, gql, handleErrorResponse };

package/dist/company-setting/index.d.ts

@@ -1,3 +1,47 @@
-export * from './create';
-export * from './fragments';
-export * from './types';
+import * as graphql0 from "graphql";
+
+//#region src/company-setting/types.d.ts
+interface DataCompanySetting {
+  companySetting: CompanySetting;
+}
+interface CompanySetting {
+  lang: string;
+  name: string;
+  description: string;
+  logo: string;
+  address_1: string;
+  address_2: string;
+  email_1: string;
+  email_2: string;
+  fb_link: string;
+  ig_link: string;
+  line_link: string;
+  phone_1: string;
+  phone_2: string;
+  twitter_link: string;
+  threads_link: string;
+}
+//#endregion
+//#region src/company-setting/create.d.ts
+declare function createCompanySetting(companySetting: Partial<CompanySetting>): {
+  lang: string;
+  name: string;
+  description: string;
+  logo: string;
+  address_1: string;
+  address_2: string;
+  email_1: string;
+  email_2: string;
+  fb_link: string;
+  ig_link: string;
+  line_link: string;
+  phone_1: string;
+  phone_2: string;
+  twitter_link: string;
+  threads_link: string;
+};
+//#endregion
+//#region src/company-setting/fragments.d.ts
+declare const companySettingFields: graphql0.DocumentNode;
+//#endregion
+export { CompanySetting, DataCompanySetting, companySettingFields, createCompanySetting };

package/dist/company-setting/index.js

@@ -1,3 +1,47 @@
-export * from "./create.js";
-export * from "./fragments.js";
-export * from "./types.js";
+import { gql } from "graphql-tag";
+
+//#region src/company-setting/create.ts
+function createCompanySetting(companySetting) {
+	return {
+		lang: companySetting.lang || "zh_TW",
+		name: companySetting.name || "Astro",
+		description: companySetting.description || "",
+		logo: companySetting.logo || "",
+		address_1: companySetting.address_1 || "",
+		address_2: companySetting.address_2 || "",
+		email_1: companySetting.email_1 || "",
+		email_2: companySetting.email_2 || "",
+		fb_link: companySetting.fb_link || "",
+		ig_link: companySetting.ig_link || "",
+		line_link: companySetting.line_link || "",
+		phone_1: companySetting.phone_1 || "",
+		phone_2: companySetting.phone_2 || "",
+		twitter_link: companySetting.twitter_link || "",
+		threads_link: companySetting.threads_link || ""
+	};
+}
+
+//#endregion
+//#region src/company-setting/fragments.ts
+const companySettingFields = gql`
+  fragment CompanySettingFields on CompanySetting {
+    lang
+    name
+    description
+    logo
+    address_1
+    address_2
+    email_1
+    email_2
+    fb_link
+    ig_link
+    line_link
+    phone_1
+    phone_2
+    twitter_link
+    threads_link
+  }
+`;
+
+//#endregion
+export { companySettingFields, createCompanySetting };

package/dist/form-validator/index.d.ts

@@ -1,6 +1,72 @@
-export { default as FormField } from './components/FormField.vue';
-export { default as FormValidatorProvider } from './components/FormValidatorProvider';
-export type { FormValidatorProviderExposed } from './components/FormValidatorProvider';
-export * from './FormValidator';
-export * from './injectionKey';
-export * from './types';
+import * as vue27 from "vue";
+import { PropType } from "vue";
+
+//#region src/form-validator/types.d.ts
+type FormErrors = Record<string, string[]>;
+interface FormRule {
+  validate: (value: any) => boolean;
+  message: string;
+}
+//#endregion
+//#region src/form-validator/FormValidator.d.ts
+declare class FormValidator {
+  rules: Record<string, FormRule[]>;
+  errors: FormErrors;
+  errorsUpdatedCallbacks: ((errors: FormErrors) => void)[];
+  validate(data: Record<string, any>): boolean;
+  prependRules(field: string, rules: FormRule | FormRule[]): void;
+  appendRules(field: string, rules: FormRule | FormRule[]): void;
+  setErrors(errors: FormErrors): void;
+  resetErrors(): void;
+  onErrorsUpdated(callback: (errors: FormErrors) => void): void;
+}
+//#endregion
+//#region src/form-validator/components/FormField.d.ts
+declare const FormField: vue27.DefineComponent<vue27.ExtractPropTypes<{
+  id: {
+    type: StringConstructor;
+    required: true;
+  };
+  rules: {
+    type: PropType<FormRule[]>;
+    default: () => never[];
+  };
+}>, () => vue27.VNode<vue27.RendererNode, vue27.RendererElement, {
+  [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue27.ComponentOptionsMixin, vue27.ComponentOptionsMixin, {}, string, vue27.PublicProps, Readonly<vue27.ExtractPropTypes<{
+  id: {
+    type: StringConstructor;
+    required: true;
+  };
+  rules: {
+    type: PropType<FormRule[]>;
+    default: () => never[];
+  };
+}>> & Readonly<{}>, {
+  rules: FormRule[];
+}, {}, {}, {}, string, vue27.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/form-validator/components/FormValidatorProvider.d.ts
+interface FormValidatorProviderExposed {
+  formValidator: () => FormValidator;
+}
+declare const FormValidatorProvider: vue27.DefineComponent<vue27.ExtractPropTypes<{
+  errors: {
+    type: PropType<FormErrors>;
+    default: () => {};
+  };
+}>, () => vue27.VNode<vue27.RendererNode, vue27.RendererElement, {
+  [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue27.ComponentOptionsMixin, vue27.ComponentOptionsMixin, {}, string, vue27.PublicProps, Readonly<vue27.ExtractPropTypes<{
+  errors: {
+    type: PropType<FormErrors>;
+    default: () => {};
+  };
+}>> & Readonly<{}>, {
+  errors: FormErrors;
+}, {}, {}, {}, string, vue27.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/form-validator/useFormValidator.d.ts
+declare function useFormValidator(): FormValidator;
+//#endregion
+export { FormErrors, FormField, FormRule, FormValidator, FormValidatorProvider, FormValidatorProviderExposed, useFormValidator };

package/dist/form-validator/index.js

@@ -1,5 +1,106 @@
-export { default as FormField } from "./components/FormField.vue";
-export { default as FormValidatorProvider } from "./components/FormValidatorProvider.js";
-export * from "./FormValidator.js";
-export * from "./injectionKey.js";
-export * from "./types.js";
+import { defineComponent, inject, onMounted, provide, ref, toRaw, watch } from "vue";
+
+//#region src/form-validator/injectionKey.ts
+const formValidatorInjectionKey = Symbol("");
+
+//#endregion
+//#region src/form-validator/useFormValidator.ts
+function useFormValidator() {
+	const formValidator = inject(formValidatorInjectionKey);
+	if (!formValidator) throw new Error("FormValidator must be provided in the <FormValidatorProvider> component context.");
+	return formValidator;
+}
+
+//#endregion
+//#region src/form-validator/components/FormField.ts
+const FormField = defineComponent({
+	name: "FormField",
+	props: {
+		id: {
+			type: String,
+			required: true
+		},
+		rules: {
+			type: Object,
+			default: () => []
+		}
+	},
+	setup(props, { slots }) {
+		const error = ref(void 0);
+		const formValidator = useFormValidator();
+		if (props.rules) formValidator.appendRules(props.id, props.rules);
+		formValidator.onErrorsUpdated((errors) => {
+			error.value = errors[props.id]?.[0];
+		});
+		return () => slots.default?.({ error: error.value });
+	}
+});
+var FormField_default = FormField;
+
+//#endregion
+//#region src/form-validator/FormValidator.ts
+var FormValidator = class {
+	rules = {};
+	errors = {};
+	errorsUpdatedCallbacks = [];
+	validate(data) {
+		const errors = {};
+		let isValid = true;
+		for (const field in this.rules) {
+			const fieldRules = this.rules[field];
+			const value = data[field];
+			for (const rule of fieldRules) if (!rule.validate(value)) {
+				isValid = false;
+				if (!errors[field]) errors[field] = [];
+				errors[field].push(rule.message);
+				break;
+			}
+		}
+		this.setErrors(errors);
+		return isValid;
+	}
+	prependRules(field, rules) {
+		if (!this.rules[field]) this.rules[field] = [];
+		this.rules[field].unshift(...Array.isArray(rules) ? rules : [rules]);
+	}
+	appendRules(field, rules) {
+		if (!this.rules[field]) this.rules[field] = [];
+		this.rules[field].push(...Array.isArray(rules) ? rules : [rules]);
+	}
+	setErrors(errors) {
+		this.errors = structuredClone(toRaw(errors));
+		this.errorsUpdatedCallbacks.forEach((callback) => callback(this.errors));
+	}
+	resetErrors() {
+		this.setErrors({});
+	}
+	onErrorsUpdated(callback) {
+		this.errorsUpdatedCallbacks.push(callback);
+	}
+};
+
+//#endregion
+//#region src/form-validator/components/FormValidatorProvider.ts
+const FormValidatorProvider = defineComponent({
+	name: "FormValidatorProvider",
+	props: { errors: {
+		type: Object,
+		default: () => ({})
+	} },
+	setup(props, { slots, expose }) {
+		const formValidator = new FormValidator();
+		provide(formValidatorInjectionKey, formValidator);
+		onMounted(() => {
+			formValidator.setErrors(props.errors);
+		});
+		watch(() => props.errors, () => {
+			formValidator.setErrors(props.errors);
+		}, { deep: true });
+		expose({ formValidator: () => formValidator });
+		return () => slots.default?.();
+	}
+});
+var FormValidatorProvider_default = FormValidatorProvider;
+
+//#endregion
+export { FormField_default as FormField, FormValidator, FormValidatorProvider_default as FormValidatorProvider, useFormValidator };

package/dist/image/index.d.ts

@@ -1,4 +1,16 @@
-export { default as Image } from './components/Image.astro';
-export { default as ResponsiveImage } from './components/ResponsiveImage.astro';
-export * from './fragments';
-export * from './types';
+import * as graphql12 from "graphql";
+
+//#region src/image/fragments.d.ts
+declare const imageFields: graphql12.DocumentNode;
+declare const coverFields: graphql12.DocumentNode;
+declare const backgroundFields: graphql12.DocumentNode;
+//#endregion
+//#region src/image/types.d.ts
+interface ImageSource {
+  desktop: string | null;
+  desktop_blur: string | null;
+  mobile: string | null;
+  mobile_blur: string | null;
+}
+//#endregion
+export { ImageSource, backgroundFields, coverFields, imageFields };

package/dist/image/index.js

@@ -1,4 +1,30 @@
-export { default as Image } from "./components/Image.astro";
-export { default as ResponsiveImage } from "./components/ResponsiveImage.astro";
-export * from "./fragments.js";
-export * from "./types.js";
+import { gql } from "graphql-tag";
+
+//#region src/image/fragments.ts
+const imageFields = gql`
+  fragment ImageFields on Image {
+    desktop
+    desktop_blur
+    mobile
+    mobile_blur
+  }
+`;
+const coverFields = gql`
+  fragment CoverFields on Cover {
+    desktop
+    desktop_blur
+    mobile
+    mobile_blur
+  }
+`;
+const backgroundFields = gql`
+  fragment BackgroundFields on Background {
+    desktop
+    desktop_blur
+    mobile
+    mobile_blur
+  }
+`;
+
+//#endregion
+export { backgroundFields, coverFields, imageFields };

package/dist/page/components/PageFieldRender.astro

@@ -1,7 +1,7 @@
 ---
-import { isContentField, isImageField, isPlainTextField, isPlainTextareaField } from '../field/helpers'
-import type { PageField } from '../types'
-import { ResponsiveImage } from '../../image'
+import { isContentField, isImageField, isPlainTextField, isPlainTextareaField } from '@stephenchenorg/astro/page'
+import type { PageField } from '@stephenchenorg/astro/page'
+import ResponsiveImage from '@stephenchenorg/astro/image/components/ResponsiveImage.astro'
 
 interface Props {
   fields: PageField[]

package/dist/page/index.d.ts

@@ -1,4 +1,101 @@
-export { default as PageFieldRender } from './components/PageFieldRender.astro';
-export * from './field';
-export * from './seo-meta';
-export * from './types';
+import * as graphql38 from "graphql";
+
+//#region src/page/field/fragments.d.ts
+
+/**
+ * Page fields fragment requires explicit import image
+ * fields fragment `imageFields` from Image module.
+ */
+declare const pageFields: graphql38.DocumentNode;
+//#endregion
+//#region src/page/types.d.ts
+interface DataPage {
+  page: Page;
+}
+interface Page extends PageMeta {
+  fields: PageField[];
+}
+interface PageMeta {
+  title: string;
+  seo_title: string | null;
+  seo_description: string | null;
+  seo_keyword: string | null;
+  seo_json_ld: string | null;
+  seo_head?: string | null;
+  seo_body?: string | null;
+  og_title: string | null;
+  og_description: string | null;
+  og_image: string | null;
+}
+interface PageField {
+  key: string;
+  type: 'text' | 'textarea' | 'html' | 'image';
+  content: string | null;
+  image: {
+    desktop: string | null;
+    desktop_blur: string | null;
+    mobile: string | null;
+    mobile_blur: string | null;
+  };
+}
+interface PagePlainTextField extends PageField {
+  type: 'text';
+  content: string;
+  image: {
+    desktop: null;
+    desktop_blur: null;
+    mobile: null;
+    mobile_blur: null;
+  };
+}
+interface PagePlainTextareaField extends PageField {
+  type: 'textarea';
+  content: string;
+  image: {
+    desktop: null;
+    desktop_blur: null;
+    mobile: null;
+    mobile_blur: null;
+  };
+}
+interface PageContentField extends PageField {
+  type: 'html';
+  content: string;
+  image: {
+    desktop: null;
+    desktop_blur: null;
+    mobile: null;
+    mobile_blur: null;
+  };
+}
+interface PageImageField extends PageField {
+  type: 'image';
+  content: null;
+  image: {
+    desktop: string;
+    desktop_blur: string;
+    mobile: string;
+    mobile_blur: string;
+  };
+}
+//#endregion
+//#region src/page/field/helpers.d.ts
+declare function isPlainTextField(field: PageField): field is PagePlainTextField;
+declare function isPlainTextareaField(field: PageField): field is PagePlainTextareaField;
+declare function isContentField(field: PageField): field is PageContentField;
+declare function isImageField(field: PageField): field is PageImageField;
+declare function pageTextField(fields: PageField[], key: string): string | null;
+declare function pageImageFieldForBackground(fields: PageField[], key: string): string;
+//#endregion
+//#region src/page/seo-meta/fragments.d.ts
+declare const seoMetaFields: (dummyClass: string) => graphql38.DocumentNode;
+//#endregion
+//#region src/page/seo-meta/helpers.d.ts
+type UseSeoMetaOptions = Partial<Omit<PageMeta, 'title'>> & {
+  title: string;
+  description?: string | null;
+  image?: string | null;
+};
+declare function seoMeta(options: UseSeoMetaOptions, modelMeta?: PageMeta): PageMeta;
+//#endregion
+export { DataPage, Page, PageContentField, PageField, PageImageField, PageMeta, PagePlainTextField, PagePlainTextareaField, UseSeoMetaOptions, isContentField, isImageField, isPlainTextField, isPlainTextareaField, pageFields, pageImageFieldForBackground, pageTextField, seoMeta, seoMetaFields };