forgepress 0.0.0 → 0.0.2

package/dist/_chunks/types.d.mts

@@ -0,0 +1,230 @@
+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]>[];
+type ProviderType = 'github' | 'gitlab' | 'forgejo';
+interface ProviderRepository {
+  owner: string;
+  name: string;
+  branch?: string;
+}
+export interface ProviderConfig {
+  type: ProviderType;
+  repository: ProviderRepository;
+  base?: string;
+  url?: string;
+  clientId?: string;
+  scopes?: readonly string[];
+  redirectUri?: string;
+  commitMessage?: string;
+}
+export 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;
+}
+interface MediaContent {
+  url: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+}
+export type ResolvedMedia = Required<MediaConfig>;
+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/types2.d.mts

@@ -0,0 +1,25 @@
+import { OutputMeta } from "./types.mjs";
+type LinkKind = 'relation' | 'dynamic';
+export interface OutputEntry extends OutputMeta {
+  [field: string]: unknown;
+}
+export interface OutputManifest {
+  indexed: string[];
+  links: Record<string, LinkKind>;
+  entries: OutputEntry[];
+  files: Record<string, string>;
+}
+export type OutputCollection = {
+  localized: false;
+  manifest: string;
+} | {
+  localized: true;
+  manifests: Record<string, string>;
+};
+export interface OutputIndex {
+  version: number;
+  commit: string | null;
+  dev?: true;
+  locales: string[];
+  collections: Record<string, OutputCollection>;
+}

package/dist/_chunks/value.mjs

@@ -0,0 +1,139 @@
+const META_KEYS = [
+	"id",
+	"status",
+	"createdAt",
+	"updatedAt"
+];
+const OUTPUT_META_KEYS = [
+	"id",
+	"createdAt",
+	"updatedAt"
+];
+const ENTRY_STATUSES = ["published", "unpublished"];
+const dynamic = {
+	type: "dynamic",
+	label: "Dynamic",
+	options: { collections: {
+		label: "Collections",
+		type: "collections",
+		required: true
+	} }
+};
+const image = {
+	type: "image",
+	label: "Image",
+	options: { multiple: {
+		label: "Multiple",
+		type: "boolean"
+	} }
+};
+const number = {
+	type: "number",
+	label: "Number",
+	options: {
+		min: {
+			label: "Minimum",
+			type: "number"
+		},
+		max: {
+			label: "Maximum",
+			type: "number"
+		},
+		step: {
+			label: "Step",
+			type: "number"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+const relation = {
+	type: "relation",
+	label: "Relation",
+	options: {
+		collection: {
+			label: "Collection",
+			type: "collection",
+			required: true
+		},
+		multiple: {
+			label: "Multiple",
+			type: "boolean"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+const richtext = {
+	type: "richtext",
+	label: "Rich Text",
+	options: {}
+};
+const text = {
+	type: "text",
+	label: "Text",
+	options: {
+		validation: {
+			label: "Validation Pattern",
+			type: "text"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+function compilePattern(validation) {
+	try {
+		return new RegExp(validation, "u");
+	} catch (error) {
+		return error;
+	}
+}
+const fieldTypes = {
+	text,
+	richtext,
+	number,
+	image,
+	video: {
+		type: "video",
+		label: "Video",
+		options: { multiple: {
+			label: "Multiple",
+			type: "boolean"
+		} }
+	},
+	relation,
+	dynamic
+};
+const fieldTypeNames = Object.keys(fieldTypes);
+function isTranslated(field, locales) {
+	return field.translate === true && locales.length > 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plain(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function same(left, right) {
+	return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function pick(record, keys) {
+	return Object.fromEntries(keys.filter((key) => record[key] !== void 0).map((key) => [key, record[key]]));
+}
+function defined(value) {
+	if (!value) return {};
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function quote(value) {
+	return JSON.stringify(value) ?? String(value);
+}
+export { ENTRY_STATUSES, META_KEYS, OUTPUT_META_KEYS, compilePattern, defined, fieldTypeNames, fieldTypes, isRecord, isTranslated, pick, plain, quote, same };

package/dist/cli/bin.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli/bin.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { errorMessage } from "../_chunks/error.mjs";
+import { ContentError, formatIssue, readContent } from "../_chunks/content.mjs";
+import { buildOutput } from "../_chunks/output.mjs";
+import { diskFiles } from "../_chunks/files.mjs";
+import { findRoot, loadConfig, resolveConfig } from "../_chunks/config.mjs";
+import process from "node:process";
+import { defineCommand, runMain } from "citty";
+var version = "0.0.2";
+function fail(message) {
+	console.error(message);
+	process.exitCode = 1;
+}
+function report(issues) {
+	fail(`${issues.map(formatIssue).join("\n")}\n\n${issues.length} ${issues.length === 1 ? "problem" : "problems"} found`);
+}
+async function inProject(cwd, task) {
+	try {
+		await task(findRoot(cwd));
+	} catch (error) {
+		if (error instanceof ContentError) return report(error.issues);
+		fail(errorMessage(error));
+	}
+}
+function createCli(cwd) {
+	const check = defineCommand({
+		meta: {
+			name: "check",
+			description: "Check the schema and all content the way the build does"
+		},
+		run: () => inProject(cwd, async (root) => {
+			const config = resolveConfig(await loadConfig(root));
+			const { issues } = await readContent(diskFiles(root), config.paths);
+			if (issues.length > 0) return report(issues);
+			console.log("No problems found");
+		})
+	});
+	const build = defineCommand({
+		meta: {
+			name: "build",
+			description: "Check the content, then write the content output"
+		},
+		run: () => inProject(cwd, async (root) => {
+			const result = await buildOutput(root, resolveConfig(await loadConfig(root)));
+			console.log(`Wrote the content output to ${result.dir} (${result.files} ${result.files === 1 ? "file" : "files"}, ${result.commit ? `commit ${result.commit.slice(0, 7)}` : "no commit found"})`);
+		})
+	});
+	return defineCommand({
+		meta: {
+			name: "forgepress",
+			version,
+			description: "Check and build the content of a ForgePress project"
+		},
+		subCommands: {
+			check,
+			build
+		}
+	});
+}
+await runMain(createCli(process.cwd()));
+export {};

package/dist/disk/reader.d.mts

@@ -0,0 +1,4 @@
+import { ContentReader } from "../_chunks/client.mjs";
+export declare const OUTPUT_VARIABLE = "FORGEPRESS_OUTPUT";
+export declare function diskReader(dir: () => Promise<string>): ContentReader;
+export declare const reader: ContentReader;

package/dist/disk/reader.mjs

@@ -0,0 +1,2 @@
+import { OUTPUT_VARIABLE, diskReader, reader } from "../_chunks/reader.mjs";
+export { OUTPUT_VARIABLE, diskReader, reader };

package/dist/editor/index.d.mts

@@ -0,0 +1,3 @@
+export type MountEditor = (target?: Element | string | null) => () => void
+
+export declare const mountEditor: MountEditor