@dosgato/templating 0.0.52 → 0.0.55

package/dist/apitemplate.d.ts

@@ -57,7 +57,7 @@ export interface DataExtras {
 /**
  * This interface lays out the structure the API needs for each template in the system.
  */
-export interface APITemplate {
+export interface APITemplate<DataType> {
     type: APITemplateType;
     /**
      * A unique string to globally identify this template across installations. Namespacing like
@@ -73,15 +73,15 @@ export interface APITemplate {
      * can be indexed. Only fields that are links need to be returned. Links inside rich editor
      * text will be extracted automatically from any text returned by getFulltext (see below)
      */
-    getLinks?: LinkGatheringFn;
+    getLinks?: LinkGatheringFn<DataType>;
     /**
      * Each template must provide the text from any text or rich editor data it possesses, so that
      * the text can be decomposed into words and indexed for fulltext searches. Any text returned
      * by this function will also be scanned for links.
      */
-    getFulltext?: FulltextGatheringFn;
+    getFulltext?: FulltextGatheringFn<DataType>;
 }
-export interface APIComponentTemplate extends APITemplate {
+export interface APIComponentTemplate<DataType extends ComponentData = any> extends APITemplate<DataType> {
     type: 'component';
     /**
      * Each template must declare its areas and the template keys of components that will be
@@ -107,15 +107,15 @@ export interface APIComponentTemplate extends APITemplate {
      *
      * See the ComponentExtras type to see all the contextual information you'll have available.
      */
-    validate?: <T extends ComponentData>(data: T, extras: ComponentExtras) => Promise<ValidationFeedback[]>;
+    validate?: (data: DataType, extras: ComponentExtras) => Promise<ValidationFeedback[]>;
     /**
      * Each template must provide a list of migrations for upgrading the data schema over time.
      * Typically this will start as an empty array and migrations will be added as the template
      * gets refactored.
      */
-    migrations?: ComponentMigration[];
+    migrations?: ComponentMigration<DataType>[];
 }
-export interface APIPageTemplate extends APITemplate {
+export interface APIPageTemplate<DataType extends PageData = any> extends APITemplate<DataType> {
     type: 'page';
     /**
      * Page areas are the same as components but are required.
@@ -124,8 +124,8 @@ export interface APIPageTemplate extends APITemplate {
     /**
      * Page template implementations do not receive a path like component templates do.
      */
-    validate?: <T extends PageData>(data: T, extras: PageExtras) => Promise<ValidationFeedback[]>;
-    migrations?: PageMigration[];
+    validate?: (data: DataType, extras: PageExtras) => Promise<ValidationFeedback[]>;
+    migrations?: PageMigration<DataType>[];
     /**
      * Hard-coded properties that may be set on page templates to influence the rendering of
      * components on the page. For instance, a set of color choices that are customized for
@@ -137,15 +137,15 @@ export interface APIPageTemplate extends APITemplate {
      */
     templateProperties?: any;
 }
-export interface APIDataTemplate extends APITemplate {
+export interface APIDataTemplate<DataType extends DataData = any> extends APITemplate<DataType> {
     type: 'data';
     /**
      * Data template implementations receive the id of the dataroot the data is/will be inside,
      * as well as the folder id (if applicable) and their own id. Keep in mind dataId will be
      * null when it is a creation operation.
      */
-    validate?: <T extends DataData>(data: T, extras: DataExtras) => Promise<ValidationFeedback[]>;
-    migrations?: DataMigration[];
+    validate?: (data: DataType, extras: DataExtras) => Promise<ValidationFeedback[]>;
+    migrations?: DataMigration<DataType>[];
 }
 export declare type APIAnyTemplate = APIComponentTemplate | APIPageTemplate | APIDataTemplate;
 /**
@@ -181,12 +181,12 @@ export interface Migration<DataType, ExtraType> {
     up: (data: DataType, extras: ExtraType) => DataType | Promise<DataType>;
     down: (data: DataType, extras: ExtraType) => DataType | Promise<DataType>;
 }
-export declare type ComponentMigration = Migration<ComponentData, ComponentExtras>;
-export declare type PageMigration = Migration<PageData, PageExtras>;
-export declare type DataMigration = Migration<DataData, DataExtras>;
+export declare type ComponentMigration<DataType extends ComponentData = ComponentData> = Migration<DataType, ComponentExtras>;
+export declare type PageMigration<DataType extends PageData = PageData> = Migration<DataType, PageExtras>;
+export declare type DataMigration<DataType extends DataData = DataData> = Migration<DataType, DataExtras>;
 export declare type AnyMigration = ComponentMigration | PageMigration | DataMigration;
-export declare type LinkGatheringFn = (data: any) => LinkDefinition[];
-export declare type FulltextGatheringFn = (data: any) => string[];
+export declare type LinkGatheringFn<DataType> = (data: DataType) => LinkDefinition[];
+export declare type FulltextGatheringFn<DataType> = (data: DataType) => string[];
 export declare type GraphQLQueryFn = <T>(query: string, variables?: any) => Promise<T>;
 /**
  * This function is used by API template definitions to help them identify all the searchable

package/dist/component.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'http';
 import { ResourceProvider } from './provider.js';
 import { APIClient } from './render.js';
 /**
@@ -179,6 +181,8 @@ export declare abstract class Component<DataType extends ComponentData = any, Fe
     renderedAreas: Map<string, RenderedComponent[]>;
     hadError: boolean;
     autoLabel: string;
+    reqHeaders: IncomingHttpHeaders;
+    reqUrl: URL;
     /**
      * For logging errors during rendering without crashing the render. If your fetch, setContext,
      * render, or renderVariation functions throw, the error will be logged but the page render will
@@ -243,6 +247,11 @@ export declare abstract class Page<DataType extends PageData = any, FetchedType
      * should place include it in the <head> element
      */
     headContent: string;
+    /**
+     * This method will be provided to page templates by the render server. You may call it
+     * at any time during fetch, context, or render, to set an HTTP header on the response
+     */
+    addHeader: (key: string, value: string | undefined) => void;
     protected passError(e: Error, path: string): void;
     constructor(page: PageRecord<DataType>, editMode: boolean);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dosgato/templating",
-  "version": "0.0.52",
+  "version": "0.0.55",
   "description": "A library to support building templates for dosgato CMS.",
   "type": "module",
   "exports": {
@@ -18,6 +18,7 @@
     "txstate-utils": "^1.7.4"
   },
   "devDependencies": {
+    "@types/node": "^18.7.11",
     "eslint-config-standard-with-typescript": "^22.0.0",
     "typescript": "^4.4.2"
   },