@palmyit/elements 0.0.0-stage → 0.1.7

package/dist/schema/deviceVisibility.d.ts

@@ -0,0 +1,19 @@
+import { DeviceName, Orientation } from './device/devices';
+export type DeviceVisibilityProp = 'showOnDesktop' | 'showOnTablet' | 'showOnMobile' | 'showOnTabletLandscape' | 'showOnMobileLandscape';
+export type DeviceVisibility = Record<DeviceVisibilityProp, boolean>;
+export declare const VISIBILITY_PROP_BY_DEVICE: Record<DeviceName, DeviceVisibilityProp>;
+export declare const LANDSCAPE_VISIBILITY_PROP_BY_DEVICE: Partial<Record<DeviceName, DeviceVisibilityProp>>;
+export declare const VISIBILITY_PROPS: DeviceVisibilityProp[];
+/** One Show for devices checkbox: a device, in one orientation when it has a landscape. */
+export type DeviceChoice = {
+    device: DeviceName;
+    orientation: Orientation;
+};
+export declare const DEVICE_CHOICES: DeviceChoice[];
+export declare function visibilityProp(device: DeviceName, orientation: Orientation): DeviceVisibilityProp;
+/**
+ * An element without the flag is shown, so pages saved before device settings stay visible.
+ * An omitted landscape flag follows the device's portrait flag.
+ */
+export declare function isShownOn(props: Partial<DeviceVisibility>, device: DeviceName, orientation?: Orientation): boolean;
+export declare function shownDeviceCount(props: Partial<DeviceVisibility>): number;

package/dist/schema/elementConfiguration.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ElementTemplate } from './elementTemplates';
+export type ElementType = 'PPage' | 'PSection' | 'PContainer' | 'PButton' | 'PText' | 'PRichText' | 'PImage' | 'PVideo' | 'PList' | 'PIcon' | 'PDivider' | 'PTextField' | 'PTextArea' | 'PCheckbox' | 'PRadio' | 'PSelect' | 'PTable';
+export type DocumentAttributes = Record<string, unknown>;
+/**
+ * The words the page history uses for an element. `summary` names one
+ * instance (a button's label). `attributes` names each editable prop path,
+ * such as `name` or `style.paddingTop`.
+ */
+export type ElementHistory<TProps> = {
+    summary: (props: TProps) => string;
+    attributes: Readonly<Record<string, string>>;
+};
+/**
+ * `attributes` parses a document node's attributes (every key except `type`
+ * and `children`) into the props the canvas renders. `toDocumentAttributes`
+ * is the reverse, used on publish before the same schema runs again.
+ */
+export type ElementConfiguration<TProps = Record<string, unknown>> = {
+    type: ElementType;
+    label: string;
+    attributes: z.ZodType<TProps>;
+    allowedChildren: readonly ElementType[];
+    templates: readonly ElementTemplate[];
+    toDocumentAttributes: (props: TProps) => DocumentAttributes;
+    history: ElementHistory<TProps>;
+};
+export type RegisteredElementConfiguration = {
+    type: ElementType;
+    label: string;
+    attributes: z.ZodType;
+    allowedChildren: readonly ElementType[];
+    templates: readonly ElementTemplate[];
+    toDocumentAttributes: (props: never) => DocumentAttributes;
+    history: ElementHistory<never>;
+};
+export declare const elementIdSchema: z.ZodString;
+export declare function defineElement<TProps>(configuration: ElementConfiguration<TProps>): ElementConfiguration<TProps>;

package/dist/schema/elementRegistry.d.ts

@@ -0,0 +1,40 @@
+import { ElementType } from './elementConfiguration';
+export declare const elementRegistry: {
+    PPage: import('./elementConfiguration').ElementConfiguration<import('./PPage/pPage.definition').PPageRootProps>;
+    PSection: import('./elementConfiguration').ElementConfiguration<import('./layoutElementConfiguration').LayoutElementProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PContainer: import('./elementConfiguration').ElementConfiguration<import('./layoutElementConfiguration').LayoutElementProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PButton: import('./elementConfiguration').ElementConfiguration<import('./linkSettings').LinkSettings & {
+        id: string;
+        name: string;
+        startIcon: string;
+        endIcon: string;
+        style: import('./PButton/pButton.definition').ButtonStyle;
+    } & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PText: import('./elementConfiguration').ElementConfiguration<import('./linkSettings').LinkSettings & {
+        id: string;
+        text: string;
+        style: import('./PText/pText.definition').TextStyle;
+    } & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PRichText: import('./elementConfiguration').ElementConfiguration<import('./PRichText/pRichText.definition').PRichTextDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PImage: import('./elementConfiguration').ElementConfiguration<import('./linkSettings').LinkSettings & {
+        id: string;
+        src: string;
+        alt: string;
+        style: import('./PImage/pImage.definition').ImageStyle;
+    } & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PVideo: import('./elementConfiguration').ElementConfiguration<import('./PVideo/pVideo.definition').PVideoDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PList: import('./elementConfiguration').ElementConfiguration<import('./PList/pList.definition').PListDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PIcon: import('./elementConfiguration').ElementConfiguration<import('./linkSettings').LinkSettings & {
+        id: string;
+        icon: string;
+        label: string;
+    } & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PDivider: import('./elementConfiguration').ElementConfiguration<import('./PDivider/pDivider.definition').PDividerDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PTextField: import('./elementConfiguration').ElementConfiguration<import('./PTextField/pTextField.definition').PTextFieldDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PTextArea: import('./elementConfiguration').ElementConfiguration<import('./PTextArea/pTextArea.definition').PTextAreaDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PCheckbox: import('./elementConfiguration').ElementConfiguration<import('./PCheckbox/pCheckbox.definition').PCheckboxDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PRadio: import('./elementConfiguration').ElementConfiguration<import('./PRadio/pRadio.definition').PRadioDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PSelect: import('./elementConfiguration').ElementConfiguration<import('./PSelect/pSelect.definition').PSelectDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+    PTable: import('./elementConfiguration').ElementConfiguration<import('./PTable/pTable.definition').PTableDocumentProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+};
+export declare function isElementType(value: unknown): value is ElementType;

package/dist/schema/elementStyleDefinitions.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ElementStyle, ElementStyleKind } from './style/elementStyle';
+import { StyleDefinition } from './styleItems';
+export declare const lengthValue: z.ZodString;
+export declare const lengthKeys: readonly [readonly ["width", "width", "Width"], readonly ["height", "height", "Height"], readonly ["minWidth", "min-width", "Min width"], readonly ["minHeight", "min-height", "Min height"], readonly ["maxWidth", "max-width", "Max width"], readonly ["maxHeight", "max-height", "Max height"], readonly ["paddingTop", "padding-top", "Padding top"], readonly ["paddingBottom", "padding-bottom", "Padding bottom"], readonly ["paddingLeft", "padding-left", "Padding left"], readonly ["paddingRight", "padding-right", "Padding right"], readonly ["marginTop", "margin-top", "Margin top"], readonly ["marginBottom", "margin-bottom", "Margin bottom"], readonly ["marginLeft", "margin-left", "Margin left"], readonly ["marginRight", "margin-right", "Margin right"], readonly ["borderRadiusTopLeft", "border-top-left-radius", "Radius top left"], readonly ["borderRadiusTopRight", "border-top-right-radius", "Radius top right"], readonly ["borderRadiusBottomRight", "border-bottom-right-radius", "Radius bottom right"], readonly ["borderRadiusBottomLeft", "border-bottom-left-radius", "Radius bottom left"]];
+export type LengthKey = (typeof lengthKeys)[number][0];
+export declare function elementStyleDefinitions(kind: ElementStyleKind, defaults: ElementStyle): StyleDefinition[];
+export declare function elementStyleSchema(definitions: StyleDefinition[], defaults: ElementStyle): z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    variable: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attribute: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+}, z.core.$strict>>>, z.ZodTransform<{
+    [x: string]: unknown;
+}, {
+    key: string;
+    value: unknown;
+    variable?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    attribute?: string | undefined;
+}[]>>, z.ZodTransform<ElementStyle, {
+    [x: string]: unknown;
+}>>;

package/dist/schema/elementTemplates.d.ts

@@ -0,0 +1,26 @@
+import { RegisteredElementConfiguration } from './elementConfiguration';
+/**
+ * A preset shown on the Templates tab. `shortcode` is a JSON object in the
+ * page-document format. A style item without its address only works for a key
+ * the element already has. `children` replaces that element's content.
+ */
+export type ElementTemplate = {
+    shortcode: string;
+    name: string;
+    /** Image URL the Templates tab shows in place of the name. */
+    graphic?: string;
+};
+export type TemplateContentItem = {
+    type: string;
+    props: Record<string, unknown>;
+};
+export type ApplyTemplateResult = {
+    ok: true;
+    props: Record<string, unknown>;
+    content?: TemplateContentItem[];
+} | {
+    ok: false;
+    message: string;
+};
+/** Returns the element's props with the template merged in and validated. */
+export declare function applyElementTemplate(configuration: RegisteredElementConfiguration, props: Record<string, unknown>, template: ElementTemplate): ApplyTemplateResult;

package/dist/schema/layoutChildren.d.ts

@@ -0,0 +1,2 @@
+import { ElementType } from './elementConfiguration';
+export declare const layoutChildren: readonly ElementType[];

package/dist/schema/layoutElementConfiguration.d.ts

@@ -0,0 +1,17 @@
+import { ElementStyle, ElementStyleKind } from './style/elementStyle';
+import { ElementType } from './elementConfiguration';
+import { ElementTemplate } from './elementTemplates';
+export type LayoutElementProps = {
+    id: string;
+    style: ElementStyle;
+};
+type LayoutElementOptions = {
+    type: ElementType;
+    label: string;
+    kind: ElementStyleKind;
+    defaultStyle: ElementStyle;
+    allowedChildren: readonly ElementType[];
+    templates: readonly ElementTemplate[];
+};
+export declare function defineLayoutElement({ type, label, kind, defaultStyle, allowedChildren, templates, }: LayoutElementOptions): import('./elementConfiguration').ElementConfiguration<LayoutElementProps & Partial<import('./deviceVisibility').DeviceVisibility> & Partial<Record<"tabletStyle" | "mobileStyle" | "tabletLandscapeStyle" | "mobileLandscapeStyle", Partial<Record<string, unknown>>>>>;
+export {};

package/dist/schema/linkSettings.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { DocumentAttributes } from './elementConfiguration';
+export declare const LINK_TARGETS: readonly ["_self", "_blank"];
+export type LinkTarget = (typeof LINK_TARGETS)[number];
+/** An empty `href` means the element is not a link. */
+export type LinkSettings = {
+    href: string;
+    target: LinkTarget;
+    description: string;
+};
+export declare const defaultLinkSettings: LinkSettings;
+export declare const linkSettingsShape: {
+    href: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
+    target: z.ZodDefault<z.ZodEnum<{
+        _self: "_self";
+        _blank: "_blank";
+    }>>;
+    description: z.ZodDefault<z.ZodString>;
+};
+export declare const linkHistoryLabels: {
+    href: string;
+    target: string;
+    description: string;
+};
+/** Writes only what differs from no link: the address, a new tab, and a description. */
+export declare function toLinkAttributes({ href, target, description }: LinkSettings): DocumentAttributes;

package/dist/schema/style/backgroundStyle.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundStyle } from '../Fields/BackgroundField/backgroundValue';
+type CssVarMap = Record<string, string | undefined>;
+/** Writes nothing until a background type is chosen, so the element keeps its own background. */
+export declare function backgroundStyleToCssVariables(style: Partial<BackgroundStyle>, prefix: string): CssVarMap;
+export {};

package/dist/schema/style/elementStyle.d.ts

@@ -0,0 +1,62 @@
+import { BackgroundStyle } from '../Fields/BackgroundField/backgroundValue';
+import { ColorValue } from '../Fields/ColorField/color-value';
+export declare const BORDER_LINE_STYLES: readonly ["none", "solid", "dashed", "dotted", "double"];
+export type BorderLineStyle = (typeof BORDER_LINE_STYLES)[number];
+export declare const FLEX_DIRECTIONS: readonly ["row", "column", "row-reverse", "column-reverse"];
+export declare const FLEX_WRAPS: readonly ["nowrap", "wrap", "wrap-reverse"];
+export declare const FLEX_JUSTIFY_CONTENTS: readonly ["flex-start", "center", "flex-end", "space-between", "space-around", "space-evenly"];
+export declare const FLEX_ALIGN_ITEMS: readonly ["stretch", "flex-start", "center", "flex-end", "baseline"];
+export declare const FLEX_ALIGN_CONTENTS: readonly ["stretch", "flex-start", "center", "flex-end", "space-between", "space-around", "space-evenly"];
+export type FlexDirection = (typeof FLEX_DIRECTIONS)[number];
+export type FlexWrap = (typeof FLEX_WRAPS)[number];
+export type FlexJustifyContent = (typeof FLEX_JUSTIFY_CONTENTS)[number];
+export type FlexAlignItems = (typeof FLEX_ALIGN_ITEMS)[number];
+export type FlexAlignContent = (typeof FLEX_ALIGN_CONTENTS)[number];
+export type ElementLayout = 'block' | 'flex' | 'grid';
+export type ElementOverflow = 'show' | 'hide';
+export type GridColumnCount = 2 | 3 | 4;
+export type ElementStyleKind = 'section' | 'container';
+export type ElementStyle = {
+    layout: ElementLayout;
+    gridColumns?: GridColumnCount;
+    flexDirection: FlexDirection;
+    flexWrap: FlexWrap;
+    justifyContent: FlexJustifyContent;
+    alignItems: FlexAlignItems;
+    alignContent: FlexAlignContent;
+    rowGap: string;
+    columnGap: string;
+    overflow: ElementOverflow;
+    overflowVertical: boolean;
+    overflowHorizontal: boolean;
+    width: string;
+    height: string;
+    minWidth: string;
+    minHeight: string;
+    maxWidth: string;
+    maxHeight: string;
+    paddingTop: string;
+    paddingBottom: string;
+    paddingLeft: string;
+    paddingRight: string;
+    marginTop: string;
+    marginBottom: string;
+    marginLeft: string;
+    marginRight: string;
+    borderRadiusTopLeft: string;
+    borderRadiusTopRight: string;
+    borderRadiusBottomRight: string;
+    borderRadiusBottomLeft: string;
+    borderWidth: string;
+    borderStyle: BorderLineStyle;
+    borderColor: ColorValue;
+} & BackgroundStyle;
+export declare const defaultElementStyle: ElementStyle;
+export declare const LENGTH_PATTERN: RegExp;
+type CssVarMap = Record<string, string | undefined>;
+export declare function sanitizeLength(value: string): string | undefined;
+export declare function sanitizeAutoAsZero(value: string): string | undefined;
+export declare function sanitizeMaxLength(value: string): string | undefined;
+export declare function sanitizeBorderWidth(value: string): string | undefined;
+export declare function elementStyleToCssVariables(storedStyle: ElementStyle, kind: ElementStyleKind): CssVarMap;
+export {};

package/dist/schema/style/page-styles.d.ts

@@ -0,0 +1,3 @@
+import { ColorValue } from '../Fields/ColorField/color-value';
+export declare function colorValueToCss(value: ColorValue): string | undefined;
+export declare function textSizeToCss(size: number): string | undefined;

package/dist/schema/styleItems.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export type StyleItem = {
+    key: string;
+    variable?: string;
+    variables?: Record<string, string>;
+    attribute?: string;
+    value: unknown;
+};
+export type StyleDefinition = {
+    key: string;
+    variable?: string;
+    variables?: Record<string, string>;
+    attribute?: string;
+    value: z.ZodType;
+    /** Omit when the key has no default and is left out until set. */
+    defaultValue?: unknown;
+    /** How the page history names this key. */
+    label?: string;
+};
+type StyleValues = Record<string, unknown>;
+export declare function styleItemsSchema(definitions: StyleDefinition[]): z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    variable: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attribute: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+}, z.core.$strict>>>, z.ZodTransform<StyleValues, {
+    key: string;
+    value: unknown;
+    variable?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    attribute?: string | undefined;
+}[]>>;
+/** A device override: only the keys the document sets, with no defaults filled in. */
+export declare function styleOverrideItemsSchema(definitions: StyleDefinition[]): z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    variable: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attribute: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+}, z.core.$strict>>>, z.ZodTransform<StyleValues, {
+    key: string;
+    value: unknown;
+    variable?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    attribute?: string | undefined;
+}[]>>;
+/** History labels keyed by the prop path that holds each style key. */
+export declare function styleLabels(definitions: StyleDefinition[], pathPrefix?: string): Record<string, string>;
+/** Keys missing from `values` (or an absent `values`) use the definition default. */
+export declare function toStyleItems(values: StyleValues | undefined, definitions: StyleDefinition[]): StyleItem[];
+export declare function toStyleOverrideItems(values: StyleValues | undefined, definitions: StyleDefinition[]): StyleItem[];
+export {};

package/dist/schema/textItems.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** One entry of a repeating text value: a list item, an option, or a column heading. */
+export type TextItem = {
+    text: string;
+};
+export declare function textItemsSchema(emptyListMessage: string, blankItemMessage: string): z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>>;
+/** Keeps only `text`, dropping keys the editor adds to array items. */
+export declare function toTextItems(items: readonly TextItem[]): TextItem[];

package/dist/tags.json

@@ -0,0 +1,19 @@
+[
+  "plmt-page",
+  "plmt-section",
+  "plmt-container",
+  "plmt-button",
+  "plmt-text",
+  "plmt-rich-text",
+  "plmt-image",
+  "plmt-video",
+  "plmt-list",
+  "plmt-icon",
+  "plmt-divider",
+  "plmt-table",
+  "plmt-text-field",
+  "plmt-text-area",
+  "plmt-checkbox",
+  "plmt-radio",
+  "plmt-select"
+]

package/dist/templates/elementSpec.d.ts

@@ -0,0 +1,15 @@
+import { ElementType } from '../schema/elementConfiguration';
+import { ElementSpec, ElementSpecOptions } from '../render/types';
+export type ShortcodeNode = {
+    type: ElementType;
+    props: Record<string, unknown>;
+    children?: ShortcodeNode[];
+};
+/**
+ * Convert one shortcode node into a semantic HTML element spec without recursing
+ * into layout children. Pass `options.children` for slots (builder) or let
+ * {@link toElementTree} fill them via recursion.
+ */
+export declare function elementSpec(node: ShortcodeNode, options?: ElementSpecOptions): ElementSpec | null;
+/** Convert a parsed shortcode node into a semantic HTML element tree. */
+export declare function toElementTree(node: ShortcodeNode): ElementSpec | null;

package/dist/templates/helpers.d.ts

@@ -0,0 +1,9 @@
+import { ElementAttribute, CssVariables, ElementSpec } from '../render/types';
+import { tags, ShortcodeTag } from '../render/tags';
+export declare function spec(tag: string, attrs?: Record<string, ElementAttribute>, children?: ElementSpec['children'], styleVars?: CssVariables): ElementSpec;
+export declare function withClass(className: ShortcodeTag, attrs?: Record<string, ElementAttribute>): Record<string, ElementAttribute>;
+export declare function linked(props: Record<string, unknown>, children: Array<ElementSpec | string>): Array<ElementSpec | string>;
+export declare function cssPrefix(type: string): string;
+export declare function nodeId(props: Record<string, unknown>): string;
+export declare function hostAttrs(props: Record<string, unknown>, className: ShortcodeTag): Record<string, ElementAttribute>;
+export { tags };

package/dist/templates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Element markup templates and HTML render helpers.
+ * Import from `@palmyit/elements/templates`.
+ */
+export type { ElementAttribute, CssVariables, ElementSpec, ElementSpecOptions, } from './render/types';
+export { escapeHtml, sanitizeRichTextHtml, renderHtml } from './render/renderHtml';
+export { toDom } from './render/toDom';
+export { styleToCssVariables } from './render/styleToVars';
+export { tags, type ShortcodeTag } from './render/tags';
+export { elementSpec, toElementTree, type ShortcodeNode, } from './templates/elementSpec';
+export { spec, linked, hostAttrs, nodeId, cssPrefix } from './templates/helpers';