forgepress 0.0.0 → 0.0.1

package/dist/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,97 @@
+# Licenses of Bundled Dependencies
+
+The published artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled Dependencies
+
+## @oxc-project/types
+
+License: MIT
+By: Boshen and oxc contributors
+Repository: https://github.com/oxc-project/oxc
+
+> MIT License
+> 
+> Copyright (c) 2024-present VoidZero Inc. & Contributors
+> Copyright (c) 2023 Boshen
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @rolldown/pluginutils
+
+License: MIT
+Repository: https://github.com/rolldown/plugins
+
+> MIT License
+> 
+> Copyright (c) 2026-present, rolldown/plugins repository contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## rolldown
+
+License: MIT
+Repository: https://github.com/rolldown/rolldown
+
+> MIT License
+> 
+> Copyright (c) 2024-present VoidZero Inc. & Contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+> 
+> end of terms and conditions
+> 
+> The licenses of externally maintained libraries from which parts of the Software is derived are listed [here](https://github.com/rolldown/rolldown/blob/main/THIRD-PARTY-LICENSE).

package/dist/_chunks/client.d.mts

@@ -0,0 +1,2 @@
+import "./types.mjs";
+export type ContentReader = (path: string) => Promise<unknown>;

package/dist/_chunks/config.d.mts

@@ -0,0 +1,35 @@
+type ProviderType = 'github' | 'gitlab' | 'forgejo';
+interface ProviderRepository {
+  owner: string;
+  name: string;
+  branch?: string;
+}
+interface ProviderConfig {
+  type: ProviderType;
+  repository: ProviderRepository;
+  base?: string;
+  url?: string;
+  clientId?: string;
+  scopes?: readonly string[];
+  redirectUri?: string;
+  commitMessage?: string;
+}
+interface ContentConfig {
+  indent?: number;
+  semi?: boolean;
+}
+export interface MediaConfig {
+  dir?: string;
+  url?: string;
+  maxSize?: number;
+}
+export interface OutputConfig {
+  dir?: string;
+}
+export interface ForgePressConfig {
+  path?: string;
+  provider?: ProviderConfig;
+  content?: ContentConfig;
+  media?: MediaConfig;
+  output?: OutputConfig;
+}

package/dist/_chunks/config.mjs

@@ -0,0 +1,37 @@
+import { errorMessage } from "./error.mjs";
+import { DEFAULT_CONTENT_PATH, createPaths, resolveMedia, resolveOutput } from "./output.mjs";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+function resolveConfig(config) {
+	return {
+		paths: createPaths(config?.path),
+		media: resolveMedia(config?.media),
+		output: resolveOutput(config?.output),
+		content: config?.content,
+		provider: config?.provider
+	};
+}
+const CONFIG_FILES = ["forgepress.config.mjs", "forgepress.config.js"];
+function marks(dir, contentPath) {
+	return CONFIG_FILES.some((file) => existsSync(join(dir, file))) || existsSync(join(dir, contentPath));
+}
+function findRoot(start = process.cwd(), contentPath = DEFAULT_CONTENT_PATH) {
+	for (let dir = start;; dir = dirname(dir)) {
+		if (marks(dir, contentPath)) return dir;
+		if (dir === dirname(dir)) return start;
+	}
+}
+async function loadConfig(root) {
+	for (const file of CONFIG_FILES) {
+		const path = join(root, file);
+		if (!existsSync(path)) continue;
+		try {
+			return (await import(pathToFileURL(path).href)).default;
+		} catch (cause) {
+			throw new Error(`[forgepress] could not load ${file}: ${errorMessage(cause)}`, { cause });
+		}
+	}
+}
+export { findRoot, loadConfig, resolveConfig };

package/dist/_chunks/entry.d.mts

@@ -0,0 +1,194 @@
+interface FieldBase {
+  label?: string;
+  description?: string;
+  optional?: boolean;
+  translate?: boolean;
+}
+type FieldOptionType = 'text' | 'number' | 'boolean' | 'collection' | 'collections';
+interface FieldOption {
+  label: string;
+  type: FieldOptionType;
+  description?: string;
+  required?: true;
+}
+interface FieldTypeDefinition {
+  type: string;
+  label: string;
+  options: Record<string, FieldOption>;
+}
+type OptionContent<TOption extends FieldOption> = TOption['type'] extends 'number' ? number : TOption['type'] extends 'boolean' ? boolean : TOption['type'] extends 'collections' ? readonly string[] : string;
+type RequiredOptions<TOptions> = { [TKey in keyof TOptions]: TOptions[TKey] extends {
+  required: true;
+} ? TKey : never; }[keyof TOptions];
+type FieldOf<TDefinition extends FieldTypeDefinition> = TDefinition extends FieldTypeDefinition ? FieldBase & {
+  type: TDefinition['type'];
+} & { [TKey in RequiredOptions<TDefinition['options']>]: OptionContent<TDefinition['options'][TKey]>; } & { [TKey in Exclude<keyof TDefinition['options'], RequiredOptions<TDefinition['options']>>]?: OptionContent<TDefinition['options'][TKey]>; } : never;
+declare const dynamic: {
+  readonly type: "dynamic";
+  readonly label: "Dynamic";
+  readonly options: {
+    readonly collections: {
+      readonly label: "Collections";
+      readonly type: "collections";
+      readonly required: true;
+    };
+  };
+};
+type DynamicField = FieldOf<typeof dynamic>;
+interface DynamicBlock<TCollectionName extends string = string> {
+  collection: TCollectionName;
+  id: string;
+}
+type DynamicFieldContent<TField extends DynamicField> = DynamicBlock<TField['collections'][number]>[];
+interface MediaContent {
+  url: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+}
+declare const image: {
+  readonly type: "image";
+  readonly label: "Image";
+  readonly options: {
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+  };
+};
+type ImageField = FieldOf<typeof image>;
+type ImageFieldContent<TField extends ImageField> = TField['multiple'] extends true ? MediaContent[] : MediaContent;
+declare const number: {
+  readonly type: "number";
+  readonly label: "Number";
+  readonly options: {
+    readonly min: {
+      readonly label: "Minimum";
+      readonly type: "number";
+    };
+    readonly max: {
+      readonly label: "Maximum";
+      readonly type: "number";
+    };
+    readonly step: {
+      readonly label: "Step";
+      readonly type: "number";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type NumberField = FieldOf<typeof number>;
+type NumberFieldContent = number;
+declare const relation: {
+  readonly type: "relation";
+  readonly label: "Relation";
+  readonly options: {
+    readonly collection: {
+      readonly label: "Collection";
+      readonly type: "collection";
+      readonly required: true;
+    };
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type RelationField = FieldOf<typeof relation>;
+type RelationFieldContent<TField extends RelationField> = TField['multiple'] extends true ? string[] : string;
+declare const richtext: {
+  readonly type: "richtext";
+  readonly label: "Rich Text";
+  readonly options: {};
+};
+type RichTextField = FieldOf<typeof richtext>;
+type RichTextFieldContent = string;
+declare const text: {
+  readonly type: "text";
+  readonly label: "Text";
+  readonly options: {
+    readonly validation: {
+      readonly label: "Validation Pattern";
+      readonly type: "text";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type TextField = FieldOf<typeof text>;
+type TextFieldContent = string;
+declare const video: {
+  readonly type: "video";
+  readonly label: "Video";
+  readonly options: {
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+  };
+};
+type VideoField = FieldOf<typeof video>;
+type VideoFieldContent<TField extends VideoField> = TField['multiple'] extends true ? MediaContent[] : MediaContent;
+type Field = TextField | RichTextField | NumberField | ImageField | VideoField | RelationField | DynamicField;
+type FieldContent<TField extends Field> = TField extends DynamicField ? DynamicFieldContent<TField> : TField extends RelationField ? RelationFieldContent<TField> : TField extends ImageField ? ImageFieldContent<TField> : TField extends VideoField ? VideoFieldContent<TField> : TField extends TextField ? TextFieldContent : TField extends NumberField ? NumberFieldContent : TField extends RichTextField ? RichTextFieldContent : never;
+interface Collection {
+  label?: string;
+  description?: string;
+  fields: Record<string, Field>;
+}
+export interface ForgePressSchema {
+  collections: Record<string, Collection>;
+  locales?: readonly string[];
+}
+export type SchemaLocale<TSchema extends ForgePressSchema> = TSchema['locales'] extends readonly string[] ? TSchema['locales'][number] : never;
+export interface ForgePressSchemaRegistry {}
+export type RegisteredSchema = ForgePressSchemaRegistry extends {
+  schema: infer TSchema extends ForgePressSchema;
+} ? TSchema : ForgePressSchema;
+export type EntryStatus = 'published' | 'unpublished';
+export interface EntryMeta {
+  id: string;
+  status: EntryStatus;
+  createdAt: string;
+  updatedAt: string;
+}
+export interface EntryRef<TCollectionName extends string = string> {
+  collection: TCollectionName;
+  id: string;
+}
+export interface OutputMeta {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+}
+export type Entry = EntryMeta & {
+  [field: string]: unknown;
+};
+type Translated<TSchema extends ForgePressSchema, TContent> = [SchemaLocale<TSchema>] extends [never] ? TContent : Record<SchemaLocale<TSchema>, TContent>;
+type PartiallyTranslated<TSchema extends ForgePressSchema, TContent> = [SchemaLocale<TSchema>] extends [never] ? TContent : Partial<Record<SchemaLocale<TSchema>, TContent>>;
+type FieldValue<TSchema extends ForgePressSchema, TField extends Field, TOptional extends boolean> = TField extends {
+  translate: true;
+} ? TOptional extends true ? PartiallyTranslated<TSchema, FieldContent<TField>> : Translated<TSchema, FieldContent<TField>> : FieldContent<TField>;
+type OptionalKeys<TCollection extends Collection> = { [TKey in keyof TCollection['fields']]-?: TCollection['fields'][TKey] extends {
+  optional: true;
+} ? TKey : never; }[keyof TCollection['fields']];
+type RequiredKeys<TCollection extends Collection> = Exclude<keyof TCollection['fields'], OptionalKeys<TCollection>>;
+type CollectionContent<TSchema extends ForgePressSchema, TCollection extends Collection> = EntryMeta & { [TKey in RequiredKeys<TCollection>]: FieldValue<TSchema, TCollection['fields'][TKey], false>; } & { [TKey in OptionalKeys<TCollection>]?: FieldValue<TSchema, TCollection['fields'][TKey], true>; };
+type EntryOf<TSchema extends ForgePressSchema, TCollectionName extends keyof TSchema['collections']> = CollectionContent<TSchema, TSchema['collections'][TCollectionName]>;
+export type ForgePressEntry<TCollectionName extends keyof RegisteredSchema['collections']> = EntryOf<RegisteredSchema, TCollectionName>;
+type OutputValue<TField extends Field> = TField extends RelationField ? TField['multiple'] extends true ? EntryRef<TField['collection']>[] : EntryRef<TField['collection']> : FieldContent<TField>;
+type CollectionOutput<TCollection extends Collection> = OutputMeta & { [TKey in RequiredKeys<TCollection>]: OutputValue<TCollection['fields'][TKey]>; } & { [TKey in OptionalKeys<TCollection>]?: OutputValue<TCollection['fields'][TKey]>; };
+export type OutputOf<TSchema extends ForgePressSchema, TCollectionName extends keyof TSchema['collections']> = CollectionOutput<TSchema['collections'][TCollectionName]>;
+export type ForgePressOutput<TCollectionName extends keyof RegisteredSchema['collections']> = OutputOf<RegisteredSchema, TCollectionName>;

package/dist/_chunks/error.mjs

@@ -0,0 +1,4 @@
+function errorMessage(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+export { errorMessage };

package/dist/_chunks/fetch.mjs

@@ -0,0 +1,13 @@
+import "./types.mjs";
+function fetchReader(url) {
+	const base = url.replace(/\/+$/, "");
+	return async (path) => {
+		const location = `${base}/${path}`;
+		const response = await fetch(location, path === "index.json" ? { cache: "no-cache" } : {});
+		if (response.status === 404 || response.ok && response.headers.get("content-type")?.includes("text/html")) return void 0;
+		if (!response.ok) throw new Error(`[forgepress] could not load ${location}: ${response.status} ${response.statusText}`.trim());
+		return response.json();
+	};
+}
+const reader = fetchReader("/content");
+export { fetchReader, reader };