@frictionless-ts/document 1.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © `2025` `Evgeny Karev`
+
+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.

package/README.md

@@ -0,0 +1,3 @@
+# @frictionless-ts/document
+
+frictionless-ts is a fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://frictionlessdata.github.io/frictionless-ts/).

package/build/document/Document.d.ts

@@ -0,0 +1,2 @@
+import type { JsonDocument } from "./types/Json.ts";
+export type Document = JsonDocument;

package/build/document/Document.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG9jdW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kb2N1bWVudC9Eb2N1bWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBKc29uRG9jdW1lbnQgfSBmcm9tIFwiLi90eXBlcy9Kc29uLnRzXCJcblxuZXhwb3J0IHR5cGUgRG9jdW1lbnQgPSBKc29uRG9jdW1lbnRcbiJdfQ==

package/build/document/index.d.ts

@@ -0,0 +1,3 @@
+export type { Document } from "./Document.ts";
+export { validateDocument } from "./validate.ts";
+export * from "./types/Json.ts";

package/build/document/index.js

@@ -0,0 +1,3 @@
+export { validateDocument } from "./validate.js";
+export * from "./types/Json.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kb2N1bWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDaEQsY0FBYyxpQkFBaUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgRG9jdW1lbnQgfSBmcm9tIFwiLi9Eb2N1bWVudC50c1wiXG5leHBvcnQgeyB2YWxpZGF0ZURvY3VtZW50IH0gZnJvbSBcIi4vdmFsaWRhdGUudHNcIlxuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXMvSnNvbi50c1wiXG4iXX0=

package/build/document/types/Base.d.ts

@@ -0,0 +1,3 @@
+export interface BaseDocument {
+    type: string;
+}

package/build/document/types/Base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2RvY3VtZW50L3R5cGVzL0Jhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQmFzZURvY3VtZW50IHtcbiAgdHlwZTogc3RyaW5nXG59XG4iXX0=

package/build/document/types/Json.d.ts

@@ -0,0 +1,5 @@
+import type { BaseDocument } from "./Base.ts";
+export interface JsonDocument extends BaseDocument {
+    type: "json";
+    data: Record<string, any>;
+}

package/build/document/types/Json.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSnNvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2RvY3VtZW50L3R5cGVzL0pzb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQmFzZURvY3VtZW50IH0gZnJvbSBcIi4vQmFzZS50c1wiXG5cbmV4cG9ydCBpbnRlcmZhY2UgSnNvbkRvY3VtZW50IGV4dGVuZHMgQmFzZURvY3VtZW50IHtcbiAgdHlwZTogXCJqc29uXCJcbiAgZGF0YTogUmVjb3JkPHN0cmluZywgYW55PlxufVxuIl19

package/build/document/validate.d.ts

@@ -0,0 +1,5 @@
+import type { Resource } from "@frictionless-ts/metadata";
+export declare function validateDocument(resource: Partial<Resource>): Promise<{
+    errors: import("@frictionless-ts/metadata").FrictionlessError[];
+    valid: boolean;
+}>;

package/build/document/validate.js

@@ -0,0 +1,25 @@
+import { createReport } from "@frictionless-ts/metadata";
+import { resolveJsonSchema } from "@frictionless-ts/metadata";
+import { inspectJsonValue } from "@frictionless-ts/metadata";
+export async function validateDocument(resource) {
+    if (resource.jsonSchema) {
+        const jsonSchema = await resolveJsonSchema(resource.jsonSchema);
+        if (!resource.data) {
+            return createReport([
+                {
+                    type: "data",
+                    message: `missing ${resource.name} data`,
+                },
+            ]);
+        }
+        if (jsonSchema) {
+            const errors = await inspectJsonValue(resource.data, { jsonSchema });
+            return createReport(errors.map(error => ({
+                type: "document/json",
+                ...error,
+            })));
+        }
+    }
+    return createReport();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/document/validate.spec.d.ts

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

package/build/document/validate.spec.js

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { validateDocument } from "./validate.js";
+describe("validateDocument", () => {
+    it("should return valid report when data matches jsonSchema", async () => {
+        const resource = {
+            name: "test-document",
+            data: {
+                name: "test-package",
+                version: "1.0.0",
+            },
+            jsonSchema: {
+                type: "object",
+                required: ["name", "version"],
+                properties: {
+                    name: { type: "string" },
+                    version: { type: "string" },
+                },
+            },
+        };
+        const report = await validateDocument(resource);
+        expect(report.valid).toBe(true);
+        expect(report.errors).toEqual([]);
+    });
+    it("should return error when data is missing with jsonSchema", async () => {
+        const resource = {
+            name: "test-document",
+            jsonSchema: {
+                type: "object",
+                required: ["name"],
+                properties: {
+                    name: { type: "string" },
+                },
+            },
+        };
+        const report = await validateDocument(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors).toEqual([
+            {
+                type: "data",
+                message: "missing test-document data",
+            },
+        ]);
+    });
+    it("should return validation errors when data does not match jsonSchema", async () => {
+        const resource = {
+            name: "test-document",
+            data: {
+                name: "test-package",
+                version: 123,
+            },
+            jsonSchema: {
+                type: "object",
+                required: ["name", "version"],
+                properties: {
+                    name: { type: "string" },
+                    version: { type: "string" },
+                },
+            },
+        };
+        const report = await validateDocument(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors).toEqual([
+            {
+                type: "document/json",
+                pointer: "/version",
+                message: "must be string",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export type { Document } from "./document/index.ts";
+export type { JsonDocument } from "./document/index.ts";
+export { convertSchemaToHtml } from "./schema/index.tsx";
+export { convertSchemaToMarkdown } from "./schema/index.ts";
+export { validateDocument } from "./document/index.ts";

package/build/index.js

@@ -0,0 +1,4 @@
+export { convertSchemaToHtml } from "./schema/index.js";
+export { convertSchemaToMarkdown } from "./schema/index.js";
+export { validateDocument } from "./document/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBb0IsQ0FBQTtBQUN4RCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUMzRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgRG9jdW1lbnQgfSBmcm9tIFwiLi9kb2N1bWVudC9pbmRleC50c1wiXG5leHBvcnQgdHlwZSB7IEpzb25Eb2N1bWVudCB9IGZyb20gXCIuL2RvY3VtZW50L2luZGV4LnRzXCJcblxuZXhwb3J0IHsgY29udmVydFNjaGVtYVRvSHRtbCB9IGZyb20gXCIuL3NjaGVtYS9pbmRleC50c3hcIlxuZXhwb3J0IHsgY29udmVydFNjaGVtYVRvTWFya2Rvd24gfSBmcm9tIFwiLi9zY2hlbWEvaW5kZXgudHNcIlxuZXhwb3J0IHsgdmFsaWRhdGVEb2N1bWVudCB9IGZyb20gXCIuL2RvY3VtZW50L2luZGV4LnRzXCJcbiJdfQ==

package/build/plugin.d.ts

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

package/build/plugin.js

@@ -0,0 +1,3 @@
+export {};
+// TODO: consider having a plugin here (e.g. plugin.convertSchema)
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxrRUFBa0UiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBUT0RPOiBjb25zaWRlciBoYXZpbmcgYSBwbHVnaW4gaGVyZSAoZS5nLiBwbHVnaW4uY29udmVydFNjaGVtYSlcbiJdfQ==

package/build/schema/convert/toHtml.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "@frictionless-ts/metadata";
+export declare function convertSchemaToHtml(schema: Schema, options?: {
+    frontmatter?: boolean;
+}): string;

package/build/schema/convert/toHtml.js

@@ -0,0 +1,170 @@
+import { prettify } from "htmlfy";
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+export function convertSchemaToHtml(schema, options) {
+    let html = prettify(renderToStaticMarkup(React.createElement(SchemaTable, { schema: schema, withTitle: !options?.frontmatter })));
+    if (options?.frontmatter) {
+        if (schema.title) {
+            html = `---\ntitle: ${schema.title}\n---\n\n${html}`;
+        }
+    }
+    return html;
+}
+function SchemaTable(props) {
+    const { schema, withTitle } = props;
+    const title = withTitle ? schema.title : undefined;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(SchemaHeader, { title: title, description: schema.description }),
+        schema.primaryKey && React.createElement(PrimaryKey, { fields: schema.primaryKey }),
+        schema.foreignKeys && schema.foreignKeys.length > 0 && (React.createElement(ForeignKeys, { foreignKeys: schema.foreignKeys })),
+        React.createElement(FieldsTable, { fields: schema.fields })));
+}
+function SchemaHeader(props) {
+    const { title, description } = props;
+    return (React.createElement(React.Fragment, null,
+        title && React.createElement("h1", { id: sanitizeId(title) }, title),
+        description && React.createElement("p", null, description)));
+}
+function FieldsTable(props) {
+    const { fields } = props;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("h2", null, "Fields"),
+        React.createElement("table", null,
+            React.createElement("colgroup", null,
+                React.createElement("col", { width: "20%" }),
+                React.createElement("col", { width: "65%" }),
+                React.createElement("col", { width: "15%" })),
+            React.createElement("thead", null,
+                React.createElement("tr", null,
+                    React.createElement("th", null, "Name"),
+                    React.createElement("th", null, "Definition"),
+                    React.createElement("th", null, "Type"))),
+            React.createElement("tbody", null, fields.map((field, index) => (React.createElement(FieldRow, { key: index, field: field })))))));
+}
+function FieldRow(props) {
+    const { field } = props;
+    const fieldName = field.name || "";
+    const fieldType = field.type || "any";
+    const fieldDescription = field.description || "";
+    let isRequired = false;
+    if ("constraints" in field && field.constraints) {
+        const c = field.constraints;
+        if (c.required) {
+            isRequired = true;
+        }
+    }
+    const constraints = extractConstraints(field);
+    return (React.createElement("tr", null,
+        React.createElement("td", { id: sanitizeId(fieldName) },
+            React.createElement("code", null,
+                React.createElement("strong", null,
+                    fieldName,
+                    !isRequired && "?"))),
+        React.createElement("td", null,
+            fieldDescription && React.createElement("p", null, fieldDescription),
+            constraints.length > 0 && (React.createElement(ConstraintsList, { constraints: constraints })),
+            (field.type === "string" || field.type === "integer") &&
+                "categories" in field &&
+                field.categories !== undefined && (React.createElement(CategoriesList, { categories: field.categories })),
+            field.examples !== undefined && (React.createElement(ExamplesList, { examples: field.examples }))),
+        React.createElement("td", null,
+            React.createElement("code", null, fieldType))));
+}
+function ConstraintsList(props) {
+    const { constraints } = props;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("strong", null, "Constraints"),
+        React.createElement("ul", null, constraints.map((constraint, index) => (React.createElement("li", { key: index },
+            constraint.name,
+            ": ",
+            React.createElement("code", null, constraint.value)))))));
+}
+function ExamplesList(props) {
+    const { examples } = props;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("strong", null, "Examples"),
+        React.createElement("ul", null, examples.map((example, index) => (React.createElement("li", { key: index },
+            React.createElement("code", null, String(example))))))));
+}
+function CategoriesList(props) {
+    const { categories } = props;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("strong", null, "Categories"),
+        React.createElement("ul", null, categories.map((category, index) => {
+            const value = typeof category === "object" ? category.value : category;
+            const label = typeof category === "object" ? category.label : undefined;
+            return (React.createElement("li", { key: index },
+                React.createElement("code", null, String(value)),
+                label && ` - ${label}`));
+        }))));
+}
+function extractConstraints(field) {
+    const constraints = [];
+    if ("constraints" in field && field.constraints) {
+        const c = field.constraints;
+        if (c.required) {
+            constraints.push({ name: "required", value: "true" });
+        }
+        if (c.unique) {
+            constraints.push({ name: "unique", value: "true" });
+        }
+        if (c.minimum !== undefined) {
+            constraints.push({ name: "minimum", value: String(c.minimum) });
+        }
+        if (c.maximum !== undefined) {
+            constraints.push({ name: "maximum", value: String(c.maximum) });
+        }
+        if (c.minLength !== undefined) {
+            constraints.push({ name: "minLength", value: String(c.minLength) });
+        }
+        if (c.maxLength !== undefined) {
+            constraints.push({ name: "maxLength", value: String(c.maxLength) });
+        }
+        if (c.pattern) {
+            constraints.push({ name: "pattern", value: c.pattern });
+        }
+        if (c.enum) {
+            const enumValues = c.enum.map((v) => String(v)).join(", ");
+            constraints.push({ name: "enum", value: enumValues });
+        }
+    }
+    return constraints;
+}
+function PrimaryKey(props) {
+    const { fields } = props;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("h2", null, "Primary Key"),
+        React.createElement("p", null,
+            React.createElement("code", null, fields.join(", ")))));
+}
+function ForeignKeys(props) {
+    const { foreignKeys } = props;
+    if (!foreignKeys)
+        return null;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("h2", null, "Foreign Keys"),
+        React.createElement("table", null,
+            React.createElement("colgroup", null,
+                React.createElement("col", { width: "40%" }),
+                React.createElement("col", { width: "30%" }),
+                React.createElement("col", { width: "30%" })),
+            React.createElement("thead", null,
+                React.createElement("tr", null,
+                    React.createElement("th", null, "Fields"),
+                    React.createElement("th", null, "Reference Resource"),
+                    React.createElement("th", null, "Reference Fields"))),
+            React.createElement("tbody", null, foreignKeys.map((fk, index) => (React.createElement("tr", { key: index },
+                React.createElement("td", null,
+                    React.createElement("code", null, fk.fields.join(", "))),
+                React.createElement("td", null,
+                    React.createElement("code", null, fk.reference.resource || "-")),
+                React.createElement("td", null,
+                    React.createElement("code", null, fk.reference.fields.join(", "))))))))));
+}
+function sanitizeId(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toHtml.js","sourceRoot":"","sources":["../../../schema/convert/toHtml.tsx"],"names":[],"mappings":"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","sourcesContent":["import type { Field, Schema } from \"@frictionless-ts/metadata\"\nimport { prettify } from \"htmlfy\"\nimport React from \"react\"\nimport { renderToStaticMarkup } from \"react-dom/server\"\n\nexport function convertSchemaToHtml(\n  schema: Schema,\n  options?: { frontmatter?: boolean },\n): string {\n  let html = prettify(\n    renderToStaticMarkup(\n      <SchemaTable schema={schema} withTitle={!options?.frontmatter} />,\n    ),\n  )\n\n  if (options?.frontmatter) {\n    if (schema.title) {\n      html = `---\\ntitle: ${schema.title}\\n---\\n\\n${html}`\n    }\n  }\n\n  return html\n}\n\nfunction SchemaTable(props: { schema: Schema; withTitle?: boolean }) {\n  const { schema, withTitle } = props\n  const title = withTitle ? schema.title : undefined\n\n  return (\n    <>\n      <SchemaHeader title={title} description={schema.description} />\n      {schema.primaryKey && <PrimaryKey fields={schema.primaryKey} />}\n      {schema.foreignKeys && schema.foreignKeys.length > 0 && (\n        <ForeignKeys foreignKeys={schema.foreignKeys} />\n      )}\n      <FieldsTable fields={schema.fields} />\n    </>\n  )\n}\n\nfunction SchemaHeader(props: { title?: string; description?: string }) {\n  const { title, description } = props\n\n  return (\n    <>\n      {title && <h1 id={sanitizeId(title)}>{title}</h1>}\n      {description && <p>{description}</p>}\n    </>\n  )\n}\n\nfunction FieldsTable(props: { fields: Field[] }) {\n  const { fields } = props\n  return (\n    <>\n      <h2>Fields</h2>\n      <table>\n        <colgroup>\n          <col width=\"20%\" />\n          <col width=\"65%\" />\n          <col width=\"15%\" />\n        </colgroup>\n        <thead>\n          <tr>\n            <th>Name</th>\n            <th>Definition</th>\n            <th>Type</th>\n          </tr>\n        </thead>\n        <tbody>\n          {fields.map((field, index) => (\n            <FieldRow key={index} field={field} />\n          ))}\n        </tbody>\n      </table>\n    </>\n  )\n}\n\nfunction FieldRow(props: { field: Field }) {\n  const { field } = props\n  const fieldName = field.name || \"\"\n  const fieldType = field.type || \"any\"\n  const fieldDescription = field.description || \"\"\n\n  let isRequired = false\n  if (\"constraints\" in field && field.constraints) {\n    const c = field.constraints as any\n    if (c.required) {\n      isRequired = true\n    }\n  }\n\n  const constraints = extractConstraints(field)\n\n  return (\n    <tr>\n      <td id={sanitizeId(fieldName)}>\n        <code>\n          <strong>\n            {fieldName}\n            {!isRequired && \"?\"}\n          </strong>\n        </code>\n      </td>\n      <td>\n        {fieldDescription && <p>{fieldDescription}</p>}\n        {constraints.length > 0 && (\n          <ConstraintsList constraints={constraints} />\n        )}\n        {(field.type === \"string\" || field.type === \"integer\") &&\n          \"categories\" in field &&\n          field.categories !== undefined && (\n            <CategoriesList categories={field.categories} />\n          )}\n        {field.examples !== undefined && (\n          <ExamplesList examples={field.examples} />\n        )}\n      </td>\n      <td>\n        <code>{fieldType}</code>\n      </td>\n    </tr>\n  )\n}\n\nfunction ConstraintsList(props: { constraints: Constraint[] }) {\n  const { constraints } = props\n  return (\n    <>\n      <strong>Constraints</strong>\n      <ul>\n        {constraints.map((constraint, index) => (\n          <li key={index}>\n            {constraint.name}: <code>{constraint.value}</code>\n          </li>\n        ))}\n      </ul>\n    </>\n  )\n}\n\nfunction ExamplesList(props: { examples: any[] }) {\n  const { examples } = props\n  return (\n    <>\n      <strong>Examples</strong>\n      <ul>\n        {examples.map((example, index) => (\n          <li key={index}>\n            <code>{String(example)}</code>\n          </li>\n        ))}\n      </ul>\n    </>\n  )\n}\n\nfunction CategoriesList(props: {\n  categories:\n    | string[]\n    | number[]\n    | Array<{ value: string | number; label: string }>\n}) {\n  const { categories } = props\n  return (\n    <>\n      <strong>Categories</strong>\n      <ul>\n        {categories.map((category, index) => {\n          const value = typeof category === \"object\" ? category.value : category\n          const label =\n            typeof category === \"object\" ? category.label : undefined\n          return (\n            <li key={index}>\n              <code>{String(value)}</code>\n              {label && ` - ${label}`}\n            </li>\n          )\n        })}\n      </ul>\n    </>\n  )\n}\n\nfunction extractConstraints(field: Field): Constraint[] {\n  const constraints: Constraint[] = []\n\n  if (\"constraints\" in field && field.constraints) {\n    const c = field.constraints as any\n\n    if (c.required) {\n      constraints.push({ name: \"required\", value: \"true\" })\n    }\n    if (c.unique) {\n      constraints.push({ name: \"unique\", value: \"true\" })\n    }\n    if (c.minimum !== undefined) {\n      constraints.push({ name: \"minimum\", value: String(c.minimum) })\n    }\n    if (c.maximum !== undefined) {\n      constraints.push({ name: \"maximum\", value: String(c.maximum) })\n    }\n    if (c.minLength !== undefined) {\n      constraints.push({ name: \"minLength\", value: String(c.minLength) })\n    }\n    if (c.maxLength !== undefined) {\n      constraints.push({ name: \"maxLength\", value: String(c.maxLength) })\n    }\n    if (c.pattern) {\n      constraints.push({ name: \"pattern\", value: c.pattern })\n    }\n    if (c.enum) {\n      const enumValues = c.enum.map((v: any) => String(v)).join(\", \")\n      constraints.push({ name: \"enum\", value: enumValues })\n    }\n  }\n\n  return constraints\n}\n\nfunction PrimaryKey(props: { fields: string[] }) {\n  const { fields } = props\n  return (\n    <>\n      <h2>Primary Key</h2>\n      <p>\n        <code>{fields.join(\", \")}</code>\n      </p>\n    </>\n  )\n}\n\nfunction ForeignKeys(props: { foreignKeys: Schema[\"foreignKeys\"] }) {\n  const { foreignKeys } = props\n  if (!foreignKeys) return null\n\n  return (\n    <>\n      <h2>Foreign Keys</h2>\n      <table>\n        <colgroup>\n          <col width=\"40%\" />\n          <col width=\"30%\" />\n          <col width=\"30%\" />\n        </colgroup>\n        <thead>\n          <tr>\n            <th>Fields</th>\n            <th>Reference Resource</th>\n            <th>Reference Fields</th>\n          </tr>\n        </thead>\n        <tbody>\n          {foreignKeys.map((fk, index) => (\n            <tr key={index}>\n              <td>\n                <code>{fk.fields.join(\", \")}</code>\n              </td>\n              <td>\n                <code>{fk.reference.resource || \"-\"}</code>\n              </td>\n              <td>\n                <code>{fk.reference.fields.join(\", \")}</code>\n              </td>\n            </tr>\n          ))}\n        </tbody>\n      </table>\n    </>\n  )\n}\n\nfunction sanitizeId(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-|-$/g, \"\")\n}\n\ninterface Constraint {\n  name: string\n  value: string\n}\n"]}

package/build/schema/convert/toHtml.spec.d.ts

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

package/build/schema/convert/toHtml.spec.js

@@ -0,0 +1,432 @@
+import { describe, expect, it } from "vitest";
+import { convertSchemaToHtml } from "./toHtml.js";
+describe("convertSchemaToHtml", () => {
+    it("converts a simple schema to html table", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "id",
+                    type: "integer",
+                    title: "Identifier",
+                    description: "Unique identifier",
+                },
+                {
+                    name: "name",
+                    type: "string",
+                    title: "Name",
+                    description: "Person name",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Fields</h2>");
+        expect(result).toContain("<table>");
+        expect(result).toContain("<th>Name</th>");
+        expect(result).toContain("<th>Definition</th>");
+        expect(result).toContain("<th>Type</th>");
+        expect(result).toContain("<strong>id?</strong>");
+        expect(result).toContain("<strong>name?</strong>");
+        expect(result).toContain("<p>Unique identifier</p>");
+        expect(result).toContain("<p>Person name</p>");
+        expect(result).toContain("<code>integer</code>");
+        expect(result).toContain("<code>string</code>");
+    });
+    it("includes schema title and description", () => {
+        const schema = {
+            title: "Test Schema",
+            description: "A test schema for validation",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain('<h1 id="test-schema">Test Schema</h1>');
+        expect(result).toContain("<p>A test schema for validation</p>");
+    });
+    it("handles field constraints", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "age",
+                    type: "integer",
+                    constraints: {
+                        required: true,
+                        minimum: 0,
+                        maximum: 120,
+                    },
+                },
+                {
+                    name: "email",
+                    type: "string",
+                    constraints: {
+                        required: true,
+                        pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<strong>Constraints</strong>");
+        expect(result).toContain("required:");
+        expect(result).toContain("<code>true</code>");
+        expect(result).toContain("minimum:");
+        expect(result).toContain("<code>0</code>");
+        expect(result).toContain("maximum:");
+        expect(result).toContain("<code>120</code>");
+        expect(result).toContain("pattern:");
+    });
+    it("handles required field indicator", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "requiredField",
+                    type: "string",
+                    constraints: {
+                        required: true,
+                    },
+                },
+                {
+                    name: "optionalField",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<strong>requiredField</strong>");
+        expect(result).not.toContain("requiredField?");
+        expect(result).toContain("<strong>optionalField?</strong>");
+    });
+    it("handles empty fields array", () => {
+        const schema = {
+            fields: [],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Fields</h2>");
+        expect(result).toContain("<table>");
+        expect(result).toContain("</table>");
+    });
+    it("escapes HTML special characters", () => {
+        const schema = {
+            title: "Test & <Schema>",
+            description: 'Description with "quotes" and <tags>',
+            fields: [
+                {
+                    name: "field",
+                    type: "string",
+                    description: "Description with <script>alert('xss')</script>",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("Test &amp; &lt;Schema&gt;");
+        expect(result).toContain("Description with &quot;quotes&quot; and &lt;tags&gt;");
+        expect(result).toContain("Description with &lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;");
+    });
+    it("handles fields with enum constraints", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: ["active", "inactive", "pending"],
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("enum:");
+        expect(result).toContain("<code>active, inactive, pending</code>");
+    });
+    it("handles multiple constraint types", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "username",
+                    type: "string",
+                    constraints: {
+                        required: true,
+                        unique: true,
+                        minLength: 3,
+                        maxLength: 20,
+                        pattern: "^[a-zA-Z0-9_]+$",
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("required:");
+        expect(result).toContain("unique:");
+        expect(result).toContain("minLength:");
+        expect(result).toContain("<code>3</code>");
+        expect(result).toContain("maxLength:");
+        expect(result).toContain("<code>20</code>");
+        expect(result).toContain("pattern:");
+    });
+    it("handles field examples", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "email",
+                    type: "string",
+                    examples: ["user@example.com", "admin@test.org"],
+                },
+                {
+                    name: "age",
+                    type: "integer",
+                    examples: [25, 30],
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<strong>Examples</strong>");
+        expect(result).toContain("<code>user@example.com</code>");
+        expect(result).toContain("<code>admin@test.org</code>");
+        expect(result).toContain("<code>25</code>");
+        expect(result).toContain("<code>30</code>");
+    });
+    it("handles different field types", () => {
+        const schema = {
+            fields: [
+                { name: "field1", type: "string" },
+                { name: "field2", type: "integer" },
+                { name: "field3", type: "number" },
+                { name: "field4", type: "boolean" },
+                { name: "field5", type: "datetime" },
+                { name: "field6", type: "any" },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<code>string</code>");
+        expect(result).toContain("<code>integer</code>");
+        expect(result).toContain("<code>number</code>");
+        expect(result).toContain("<code>boolean</code>");
+        expect(result).toContain("<code>datetime</code>");
+        expect(result).toContain("<code>any</code>");
+    });
+    it("sanitizes IDs for anchors", () => {
+        const schema = {
+            title: "Test Schema & More!",
+            fields: [
+                {
+                    name: "field-with-dashes",
+                    type: "string",
+                },
+                {
+                    name: "Field With Spaces",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain('id="test-schema-more"');
+        expect(result).toContain('id="field-with-dashes"');
+        expect(result).toContain('id="field-with-spaces"');
+    });
+    it("does not include top-level html tags", () => {
+        const schema = {
+            title: "Test",
+            fields: [{ name: "field1", type: "string" }],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).not.toContain("<!DOCTYPE");
+        expect(result).not.toContain("<html>");
+        expect(result).not.toContain("<head>");
+        expect(result).not.toContain("<body>");
+        expect(result).not.toContain("<style>");
+    });
+    it("handles schema without title", () => {
+        const schema = {
+            description: "Description only",
+            fields: [{ name: "field1", type: "string" }],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<p>Description only</p>");
+        expect(result).not.toContain("<h2 id=");
+        expect(result).toContain("<h2>Fields</h2>");
+    });
+    it("handles field without description", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<strong>field1?</strong>");
+        expect(result).toContain("<code>string</code>");
+    });
+    it("uses frontmatter when frontmatter option is true", () => {
+        const schema = {
+            title: "Test Schema",
+            description: "A test schema with frontmatter",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema, { frontmatter: true });
+        expect(result).toContain("---");
+        expect(result).toContain("Test Schema");
+        expect(result).not.toContain("<h1");
+        expect(result).toContain("<p>A test schema with frontmatter</p>");
+    });
+    it("uses H1 heading when frontmatter option is false or not provided", () => {
+        const schema = {
+            title: "Test Schema",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema, { frontmatter: false });
+        expect(result).toContain('<h1 id="test-schema">Test Schema</h1>');
+        expect(result).not.toContain("title: Test Schema");
+        expect(result.startsWith("<h1")).toBe(true);
+    });
+    it("handles schema with primary key", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "id",
+                    type: "integer",
+                },
+                {
+                    name: "name",
+                    type: "string",
+                },
+            ],
+            primaryKey: ["id"],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Primary Key</h2>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("handles schema with composite primary key", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "user_id",
+                    type: "integer",
+                },
+                {
+                    name: "project_id",
+                    type: "integer",
+                },
+            ],
+            primaryKey: ["user_id", "project_id"],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Primary Key</h2>");
+        expect(result).toContain("<code>user_id, project_id</code>");
+    });
+    it("handles schema with foreign keys", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "user_id",
+                    type: "integer",
+                },
+            ],
+            foreignKeys: [
+                {
+                    fields: ["user_id"],
+                    reference: {
+                        resource: "users",
+                        fields: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<th>Fields</th>");
+        expect(result).toContain("<th>Reference Resource</th>");
+        expect(result).toContain("<th>Reference Fields</th>");
+        expect(result).toContain("<code>user_id</code>");
+        expect(result).toContain("<code>users</code>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("handles schema with multiple foreign keys", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "user_id",
+                    type: "integer",
+                },
+                {
+                    name: "project_id",
+                    type: "integer",
+                },
+            ],
+            foreignKeys: [
+                {
+                    fields: ["user_id"],
+                    reference: {
+                        resource: "users",
+                        fields: ["id"],
+                    },
+                },
+                {
+                    fields: ["project_id"],
+                    reference: {
+                        resource: "projects",
+                        fields: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<code>user_id</code>");
+        expect(result).toContain("<code>users</code>");
+        expect(result).toContain("<code>project_id</code>");
+        expect(result).toContain("<code>projects</code>");
+    });
+    it("handles foreign key without resource specified", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "parent_id",
+                    type: "integer",
+                },
+            ],
+            foreignKeys: [
+                {
+                    fields: ["parent_id"],
+                    reference: {
+                        fields: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<code>parent_id</code>");
+        expect(result).toContain("<code>-</code>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("does not render primary key or foreign keys sections when not present", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToHtml(schema);
+        expect(result).not.toContain("<h2>Primary Key</h2>");
+        expect(result).not.toContain("<h2>Foreign Keys</h2>");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toHtml.spec.js","sourceRoot":"","sources":["../../../schema/convert/toHtml.spec.tsx"],"names":[],"mappings":"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","sourcesContent":["import type { Schema } from \"@frictionless-ts/metadata\"\nimport { describe, expect, it } from \"vitest\"\nimport { convertSchemaToHtml } from \"./toHtml.tsx\"\n\ndescribe(\"convertSchemaToHtml\", () => {\n  it(\"converts a simple schema to html table\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"id\",\n          type: \"integer\",\n          title: \"Identifier\",\n          description: \"Unique identifier\",\n        },\n        {\n          name: \"name\",\n          type: \"string\",\n          title: \"Name\",\n          description: \"Person name\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Fields</h2>\")\n    expect(result).toContain(\"<table>\")\n    expect(result).toContain(\"<th>Name</th>\")\n    expect(result).toContain(\"<th>Definition</th>\")\n    expect(result).toContain(\"<th>Type</th>\")\n    expect(result).toContain(\"<strong>id?</strong>\")\n    expect(result).toContain(\"<strong>name?</strong>\")\n    expect(result).toContain(\"<p>Unique identifier</p>\")\n    expect(result).toContain(\"<p>Person name</p>\")\n    expect(result).toContain(\"<code>integer</code>\")\n    expect(result).toContain(\"<code>string</code>\")\n  })\n\n  it(\"includes schema title and description\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      description: \"A test schema for validation\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain('<h1 id=\"test-schema\">Test Schema</h1>')\n    expect(result).toContain(\"<p>A test schema for validation</p>\")\n  })\n\n  it(\"handles field constraints\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"age\",\n          type: \"integer\",\n          constraints: {\n            required: true,\n            minimum: 0,\n            maximum: 120,\n          },\n        },\n        {\n          name: \"email\",\n          type: \"string\",\n          constraints: {\n            required: true,\n            pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<strong>Constraints</strong>\")\n    expect(result).toContain(\"required:\")\n    expect(result).toContain(\"<code>true</code>\")\n    expect(result).toContain(\"minimum:\")\n    expect(result).toContain(\"<code>0</code>\")\n    expect(result).toContain(\"maximum:\")\n    expect(result).toContain(\"<code>120</code>\")\n    expect(result).toContain(\"pattern:\")\n  })\n\n  it(\"handles required field indicator\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"requiredField\",\n          type: \"string\",\n          constraints: {\n            required: true,\n          },\n        },\n        {\n          name: \"optionalField\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<strong>requiredField</strong>\")\n    expect(result).not.toContain(\"requiredField?\")\n    expect(result).toContain(\"<strong>optionalField?</strong>\")\n  })\n\n  it(\"handles empty fields array\", () => {\n    const schema: Schema = {\n      fields: [],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Fields</h2>\")\n    expect(result).toContain(\"<table>\")\n    expect(result).toContain(\"</table>\")\n  })\n\n  it(\"escapes HTML special characters\", () => {\n    const schema: Schema = {\n      title: \"Test & <Schema>\",\n      description: 'Description with \"quotes\" and <tags>',\n      fields: [\n        {\n          name: \"field\",\n          type: \"string\",\n          description: \"Description with <script>alert('xss')</script>\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"Test &amp; &lt;Schema&gt;\")\n    expect(result).toContain(\n      \"Description with &quot;quotes&quot; and &lt;tags&gt;\",\n    )\n    expect(result).toContain(\n      \"Description with &lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;\",\n    )\n  })\n\n  it(\"handles fields with enum constraints\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: [\"active\", \"inactive\", \"pending\"],\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"enum:\")\n    expect(result).toContain(\"<code>active, inactive, pending</code>\")\n  })\n\n  it(\"handles multiple constraint types\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"username\",\n          type: \"string\",\n          constraints: {\n            required: true,\n            unique: true,\n            minLength: 3,\n            maxLength: 20,\n            pattern: \"^[a-zA-Z0-9_]+$\",\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"required:\")\n    expect(result).toContain(\"unique:\")\n    expect(result).toContain(\"minLength:\")\n    expect(result).toContain(\"<code>3</code>\")\n    expect(result).toContain(\"maxLength:\")\n    expect(result).toContain(\"<code>20</code>\")\n    expect(result).toContain(\"pattern:\")\n  })\n\n  it(\"handles field examples\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"email\",\n          type: \"string\",\n          examples: [\"user@example.com\", \"admin@test.org\"],\n        },\n        {\n          name: \"age\",\n          type: \"integer\",\n          examples: [25, 30],\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<strong>Examples</strong>\")\n    expect(result).toContain(\"<code>user@example.com</code>\")\n    expect(result).toContain(\"<code>admin@test.org</code>\")\n    expect(result).toContain(\"<code>25</code>\")\n    expect(result).toContain(\"<code>30</code>\")\n  })\n\n  it(\"handles different field types\", () => {\n    const schema: Schema = {\n      fields: [\n        { name: \"field1\", type: \"string\" },\n        { name: \"field2\", type: \"integer\" },\n        { name: \"field3\", type: \"number\" },\n        { name: \"field4\", type: \"boolean\" },\n        { name: \"field5\", type: \"datetime\" },\n        { name: \"field6\", type: \"any\" },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<code>string</code>\")\n    expect(result).toContain(\"<code>integer</code>\")\n    expect(result).toContain(\"<code>number</code>\")\n    expect(result).toContain(\"<code>boolean</code>\")\n    expect(result).toContain(\"<code>datetime</code>\")\n    expect(result).toContain(\"<code>any</code>\")\n  })\n\n  it(\"sanitizes IDs for anchors\", () => {\n    const schema: Schema = {\n      title: \"Test Schema & More!\",\n      fields: [\n        {\n          name: \"field-with-dashes\",\n          type: \"string\",\n        },\n        {\n          name: \"Field With Spaces\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain('id=\"test-schema-more\"')\n    expect(result).toContain('id=\"field-with-dashes\"')\n    expect(result).toContain('id=\"field-with-spaces\"')\n  })\n\n  it(\"does not include top-level html tags\", () => {\n    const schema: Schema = {\n      title: \"Test\",\n      fields: [{ name: \"field1\", type: \"string\" }],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).not.toContain(\"<!DOCTYPE\")\n    expect(result).not.toContain(\"<html>\")\n    expect(result).not.toContain(\"<head>\")\n    expect(result).not.toContain(\"<body>\")\n    expect(result).not.toContain(\"<style>\")\n  })\n\n  it(\"handles schema without title\", () => {\n    const schema: Schema = {\n      description: \"Description only\",\n      fields: [{ name: \"field1\", type: \"string\" }],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<p>Description only</p>\")\n    expect(result).not.toContain(\"<h2 id=\")\n    expect(result).toContain(\"<h2>Fields</h2>\")\n  })\n\n  it(\"handles field without description\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<strong>field1?</strong>\")\n    expect(result).toContain(\"<code>string</code>\")\n  })\n\n  it(\"uses frontmatter when frontmatter option is true\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      description: \"A test schema with frontmatter\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema, { frontmatter: true })\n\n    expect(result).toContain(\"---\")\n    expect(result).toContain(\"Test Schema\")\n    expect(result).not.toContain(\"<h1\")\n    expect(result).toContain(\"<p>A test schema with frontmatter</p>\")\n  })\n\n  it(\"uses H1 heading when frontmatter option is false or not provided\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema, { frontmatter: false })\n\n    expect(result).toContain('<h1 id=\"test-schema\">Test Schema</h1>')\n    expect(result).not.toContain(\"title: Test Schema\")\n    expect(result.startsWith(\"<h1\")).toBe(true)\n  })\n\n  it(\"handles schema with primary key\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"id\",\n          type: \"integer\",\n        },\n        {\n          name: \"name\",\n          type: \"string\",\n        },\n      ],\n      primaryKey: [\"id\"],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Primary Key</h2>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"handles schema with composite primary key\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"user_id\",\n          type: \"integer\",\n        },\n        {\n          name: \"project_id\",\n          type: \"integer\",\n        },\n      ],\n      primaryKey: [\"user_id\", \"project_id\"],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Primary Key</h2>\")\n    expect(result).toContain(\"<code>user_id, project_id</code>\")\n  })\n\n  it(\"handles schema with foreign keys\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"user_id\",\n          type: \"integer\",\n        },\n      ],\n      foreignKeys: [\n        {\n          fields: [\"user_id\"],\n          reference: {\n            resource: \"users\",\n            fields: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<th>Fields</th>\")\n    expect(result).toContain(\"<th>Reference Resource</th>\")\n    expect(result).toContain(\"<th>Reference Fields</th>\")\n    expect(result).toContain(\"<code>user_id</code>\")\n    expect(result).toContain(\"<code>users</code>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"handles schema with multiple foreign keys\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"user_id\",\n          type: \"integer\",\n        },\n        {\n          name: \"project_id\",\n          type: \"integer\",\n        },\n      ],\n      foreignKeys: [\n        {\n          fields: [\"user_id\"],\n          reference: {\n            resource: \"users\",\n            fields: [\"id\"],\n          },\n        },\n        {\n          fields: [\"project_id\"],\n          reference: {\n            resource: \"projects\",\n            fields: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<code>user_id</code>\")\n    expect(result).toContain(\"<code>users</code>\")\n    expect(result).toContain(\"<code>project_id</code>\")\n    expect(result).toContain(\"<code>projects</code>\")\n  })\n\n  it(\"handles foreign key without resource specified\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"parent_id\",\n          type: \"integer\",\n        },\n      ],\n      foreignKeys: [\n        {\n          fields: [\"parent_id\"],\n          reference: {\n            fields: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<code>parent_id</code>\")\n    expect(result).toContain(\"<code>-</code>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"does not render primary key or foreign keys sections when not present\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToHtml(schema)\n\n    expect(result).not.toContain(\"<h2>Primary Key</h2>\")\n    expect(result).not.toContain(\"<h2>Foreign Keys</h2>\")\n  })\n})\n"]}

package/build/schema/convert/toMarkdown.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "@frictionless-ts/metadata";
+export declare function convertSchemaToMarkdown(schema: Schema, options?: {
+    frontmatter?: boolean;
+}): string;

package/build/schema/convert/toMarkdown.js

@@ -0,0 +1,75 @@
+export function convertSchemaToMarkdown(schema, options) {
+    const rows = [];
+    rows.push("");
+    rows.push("## Fields");
+    rows.push("");
+    rows.push("| Name | Type | Title | Description | Constraints |");
+    rows.push("|------|------|-------|-------------|-------------|");
+    for (const field of schema.fields) {
+        const name = field.name || "";
+        const type = field.type || "any";
+        const title = field.title || "";
+        const description = field.description || "";
+        const constraints = [];
+        if ("required" in field && field.required) {
+            constraints.push("required");
+        }
+        if ("constraints" in field && field.constraints) {
+            const c = field.constraints;
+            if (c.required)
+                constraints.push("required");
+            if (c.unique)
+                constraints.push("unique");
+            if (c.minimum !== undefined)
+                constraints.push(`min: ${c.minimum}`);
+            if (c.maximum !== undefined)
+                constraints.push(`max: ${c.maximum}`);
+            if (c.minLength !== undefined)
+                constraints.push(`minLength: ${c.minLength}`);
+            if (c.maxLength !== undefined)
+                constraints.push(`maxLength: ${c.maxLength}`);
+            if (c.pattern)
+                constraints.push(`pattern: ${c.pattern}`);
+            if (c.enum)
+                constraints.push(`enum: ${c.enum.join(", ")}`);
+        }
+        const constraintsStr = constraints.join(", ");
+        const escapedName = escapeMarkdown(name);
+        const escapedTitle = escapeMarkdown(title);
+        const escapedDescription = escapeMarkdown(description);
+        const escapedConstraints = escapeMarkdown(constraintsStr);
+        rows.push(`| ${escapedName} | ${type} | ${escapedTitle} | ${escapedDescription} | ${escapedConstraints} |`);
+    }
+    let markdown = `${rows.join("\n")}\n`;
+    if (schema.title || schema.description) {
+        const header = [];
+        if (options?.frontmatter) {
+            header.push("---");
+            if (schema.title) {
+                header.push(`title: ${schema.title}`);
+            }
+            header.push("---");
+            header.push("");
+            if (schema.description) {
+                header.push(schema.description);
+                header.push("");
+            }
+        }
+        else {
+            if (schema.title) {
+                header.push(`# ${schema.title}`);
+                header.push("");
+            }
+            if (schema.description) {
+                header.push(schema.description);
+                header.push("");
+            }
+        }
+        markdown = header.join("\n") + markdown;
+    }
+    return markdown;
+}
+function escapeMarkdown(text) {
+    return text.replace(/\n/g, " ");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/convert/toMarkdown.spec.d.ts

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

package/build/schema/convert/toMarkdown.spec.js

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { convertSchemaToMarkdown } from "./toMarkdown.js";
+describe("convertSchemaToMarkdown", () => {
+    it("converts a simple schema to markdown table", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "id",
+                    type: "integer",
+                    title: "Identifier",
+                    description: "Unique identifier",
+                },
+                {
+                    name: "name",
+                    type: "string",
+                    title: "Name",
+                    description: "Person name",
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("| Name | Type | Title | Description | Constraints |");
+        expect(result).toContain("| id | integer | Identifier | Unique identifier |");
+        expect(result).toContain("| name | string | Name | Person name |");
+    });
+    it("includes schema title and description", () => {
+        const schema = {
+            title: "Test Schema",
+            description: "A test schema for validation",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("# Test Schema");
+        expect(result).toContain("A test schema for validation");
+    });
+    it("handles field constraints", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "age",
+                    type: "integer",
+                    constraints: {
+                        required: true,
+                        minimum: 0,
+                        maximum: 120,
+                    },
+                },
+                {
+                    name: "email",
+                    type: "string",
+                    constraints: {
+                        required: true,
+                        pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("required");
+        expect(result).toContain("min: 0");
+        expect(result).toContain("max: 120");
+        expect(result).toContain("pattern:");
+    });
+    it("handles empty fields array", () => {
+        const schema = {
+            fields: [],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("| Name | Type | Title | Description | Constraints |");
+    });
+    it("handles pipe characters in field values", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "field",
+                    type: "string",
+                    description: "Description with pipe character",
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("Description with pipe character");
+    });
+    it("handles fields with enum constraints", () => {
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: ["active", "inactive", "pending"],
+                    },
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema);
+        expect(result).toContain("enum: active, inactive, pending");
+    });
+    it("uses frontmatter when frontmatter option is true", () => {
+        const schema = {
+            title: "Test Schema",
+            description: "A test schema with frontmatter",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema, { frontmatter: true });
+        expect(result).toContain("---");
+        expect(result).toContain("title: Test Schema");
+        expect(result).not.toContain("# Test Schema");
+        expect(result).toContain("A test schema with frontmatter");
+    });
+    it("uses H1 heading when frontmatter option is false or not provided", () => {
+        const schema = {
+            title: "Test Schema",
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const result = convertSchemaToMarkdown(schema, { frontmatter: false });
+        expect(result).toContain("# Test Schema");
+        expect(result).not.toContain("title: Test Schema");
+        expect(result.startsWith("# Test Schema")).toBe(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toMarkdown.spec.js","sourceRoot":"","sources":["../../../schema/convert/toMarkdown.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Schema } from \"@frictionless-ts/metadata\"\nimport { describe, expect, it } from \"vitest\"\nimport { convertSchemaToMarkdown } from \"./toMarkdown.ts\"\n\ndescribe(\"convertSchemaToMarkdown\", () => {\n  it(\"converts a simple schema to markdown table\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"id\",\n          type: \"integer\",\n          title: \"Identifier\",\n          description: \"Unique identifier\",\n        },\n        {\n          name: \"name\",\n          type: \"string\",\n          title: \"Name\",\n          description: \"Person name\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\n      \"| Name | Type | Title | Description | Constraints |\",\n    )\n    expect(result).toContain(\n      \"| id | integer | Identifier | Unique identifier |\",\n    )\n    expect(result).toContain(\"| name | string | Name | Person name |\")\n  })\n\n  it(\"includes schema title and description\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      description: \"A test schema for validation\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\"# Test Schema\")\n    expect(result).toContain(\"A test schema for validation\")\n  })\n\n  it(\"handles field constraints\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"age\",\n          type: \"integer\",\n          constraints: {\n            required: true,\n            minimum: 0,\n            maximum: 120,\n          },\n        },\n        {\n          name: \"email\",\n          type: \"string\",\n          constraints: {\n            required: true,\n            pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\"required\")\n    expect(result).toContain(\"min: 0\")\n    expect(result).toContain(\"max: 120\")\n    expect(result).toContain(\"pattern:\")\n  })\n\n  it(\"handles empty fields array\", () => {\n    const schema: Schema = {\n      fields: [],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\n      \"| Name | Type | Title | Description | Constraints |\",\n    )\n  })\n\n  it(\"handles pipe characters in field values\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"field\",\n          type: \"string\",\n          description: \"Description with pipe character\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\"Description with pipe character\")\n  })\n\n  it(\"handles fields with enum constraints\", () => {\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: [\"active\", \"inactive\", \"pending\"],\n          },\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema)\n\n    expect(result).toContain(\"enum: active, inactive, pending\")\n  })\n\n  it(\"uses frontmatter when frontmatter option is true\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      description: \"A test schema with frontmatter\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema, { frontmatter: true })\n\n    expect(result).toContain(\"---\")\n    expect(result).toContain(\"title: Test Schema\")\n    expect(result).not.toContain(\"# Test Schema\")\n    expect(result).toContain(\"A test schema with frontmatter\")\n  })\n\n  it(\"uses H1 heading when frontmatter option is false or not provided\", () => {\n    const schema: Schema = {\n      title: \"Test Schema\",\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const result = convertSchemaToMarkdown(schema, { frontmatter: false })\n\n    expect(result).toContain(\"# Test Schema\")\n    expect(result).not.toContain(\"title: Test Schema\")\n    expect(result.startsWith(\"# Test Schema\")).toBe(true)\n  })\n})\n"]}

package/build/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { convertSchemaToHtml } from "./convert/toHtml.tsx";
+export { convertSchemaToMarkdown } from "./convert/toMarkdown.ts";

package/build/schema/index.js

@@ -0,0 +1,3 @@
+export { convertSchemaToHtml } from "./convert/toHtml.js";
+export { convertSchemaToMarkdown } from "./convert/toMarkdown.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zY2hlbWEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUJBQXNCLENBQUE7QUFDMUQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBjb252ZXJ0U2NoZW1hVG9IdG1sIH0gZnJvbSBcIi4vY29udmVydC90b0h0bWwudHN4XCJcbmV4cG9ydCB7IGNvbnZlcnRTY2hlbWFUb01hcmtkb3duIH0gZnJvbSBcIi4vY29udmVydC90b01hcmtkb3duLnRzXCJcbiJdfQ==

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@frictionless-ts/document",
+  "type": "module",
+  "version": "1.0.1",
+  "exports": "./build/index.js",
+  "sideEffects": false,
+  "files": [
+    "build"
+  ],
+  "license": "MIT",
+  "author": "Evgeny Karev",
+  "repository": "https://github.com/frictionlessdata/frictionless-ts",
+  "description": "Fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames",
+  "keywords": [
+    "frictionless",
+    "data",
+    "polars",
+    "dataframe",
+    "datapackage",
+    "tableschema",
+    "typescript",
+    "validation",
+    "quality",
+    "fair",
+    "document",
+    "html"
+  ],
+  "dependencies": {
+    "htmlfy": "^1.0.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "remark": "^15.0.1",
+    "remark-gfm": "^4.0.0",
+    "@frictionless-ts/metadata": "1.0.1",
+    "@frictionless-ts/dataset": "1.0.1"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}