@sorane/okf 0.2.1 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorane/okf",
-  "version": "0.2.1",
+  "version": "0.2.7",
   "description": "Open Knowledge Format parsing, validation, and serialization for sorane",
   "type": "module",
   "license": "MIT",

package/profile/sorane-okf-0.3.schema.json

@@ -0,0 +1,171 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://sorane.dev/profile/sorane-okf/0.3",
+  "title": "sorane-okf/0.3",
+  "description": "OKF v0.1 profile for sorane SSG: extended types, open-data metadata, AI disclosure.",
+  "oneOf": [
+    { "$ref": "#/$defs/article" },
+    { "$ref": "#/$defs/index" },
+    { "$ref": "#/$defs/dataset" },
+    { "$ref": "#/$defs/reference" },
+    { "$ref": "#/$defs/glossary" },
+    { "$ref": "#/$defs/faq" }
+  ],
+  "$defs": {
+    "publisher": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "url": { "type": "string", "minLength": 1 },
+        "email": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "distribution": {
+      "type": "object",
+      "required": ["title", "format", "accessURL"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "format": { "type": "string", "minLength": 1 },
+        "accessURL": { "type": "string", "minLength": 1 },
+        "downloadURL": { "type": "string", "minLength": 1 },
+        "byteSize": { "type": "integer", "minimum": 0 },
+        "checksum": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "temporal": {
+      "type": "object",
+      "properties": {
+        "start": { "type": "string", "minLength": 1 },
+        "end": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "okfBase": {
+      "type": "object",
+      "required": ["type"],
+      "properties": {
+        "type": { "type": "string", "minLength": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "description": { "type": "string" },
+        "resource": { "type": "string" },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "timestamp": { "type": "string", "format": "date-time" },
+        "profile": { "type": "string" },
+        "identifier": { "type": "string", "minLength": 1 },
+        "language": { "type": "string", "minLength": 2 },
+        "license": { "type": "string", "minLength": 1 },
+        "publisher": { "$ref": "#/$defs/publisher" },
+        "theme": { "type": "string", "minLength": 1 },
+        "temporal": { "$ref": "#/$defs/temporal" },
+        "spatial": { "type": "string", "minLength": 1 },
+        "distributions": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/distribution" }
+        },
+        "creativeWorkType": {
+          "type": "string",
+          "enum": ["BlogPosting", "TechArticle"]
+        },
+        "digitalSourceType": {
+          "type": "string",
+          "minLength": 1
+        },
+        "euAiLabel": {
+          "type": "string",
+          "enum": ["basic", "fully-generated", "partially-modified"]
+        },
+        "aiDisclosureNote": { "type": "string", "maxLength": 500 },
+        "aiSystems": {
+          "type": "array",
+          "maxItems": 10,
+          "items": {
+            "type": "object",
+            "required": ["name"],
+            "properties": {
+              "name": { "type": "string", "minLength": 1 },
+              "version": { "type": "string" },
+              "provider": { "type": "string" }
+            },
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": true
+    },
+    "article": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": { "type": { "const": "article" } },
+          "required": ["type", "title"]
+        }
+      ]
+    },
+    "index": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": { "type": { "const": "index" } },
+          "required": ["type", "title"]
+        }
+      ]
+    },
+    "dataset": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": {
+            "type": { "const": "dataset" },
+            "distributions": {
+              "type": "array",
+              "minItems": 1,
+              "items": { "$ref": "#/$defs/distribution" }
+            }
+          },
+          "required": [
+            "type",
+            "title",
+            "description",
+            "resource",
+            "license",
+            "publisher",
+            "distributions"
+          ]
+        }
+      ]
+    },
+    "reference": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": { "type": { "const": "reference" } },
+          "required": ["type", "title"]
+        }
+      ]
+    },
+    "glossary": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": { "type": { "const": "glossary" } },
+          "required": ["type", "title"]
+        }
+      ]
+    },
+    "faq": {
+      "allOf": [
+        { "$ref": "#/$defs/okfBase" },
+        {
+          "properties": { "type": { "const": "faq" } },
+          "required": ["type", "title"]
+        }
+      ]
+    }
+  }
+}

package/src/index.ts

@@ -12,6 +12,17 @@ export {
   type ValidationResult,
   type ValidationIssue,
 } from "./validate.ts";
+export {
+  DEFAULT_PROFILE,
+  SUPPORTED_PROFILE_RE,
+  TYPES_03,
+  TYPES_01_02,
+  BUILDABLE_CONTENT_TYPES,
+  isProfile03,
+  resolveEffectiveType,
+  isBuildableContentType,
+  resolveProfileForValidation,
+} from "./profile.ts";
 export {
   IPTC_BASE,
   resolveDigitalSourceType,

package/src/profile.ts

@@ -0,0 +1,62 @@
+export const SUPPORTED_PROFILE_RE = /^sorane-okf\/(0\.[123])$/;
+export const DEFAULT_PROFILE = "sorane-okf/0.1";
+
+export const TYPES_01_02 = new Set(["article", "index"]);
+
+export const TYPES_03 = new Set([
+  "article",
+  "index",
+  "dataset",
+  "reference",
+  "glossary",
+  "faq",
+]);
+
+export const BUILDABLE_CONTENT_TYPES = new Set([
+  "article",
+  "dataset",
+  "reference",
+  "glossary",
+  "faq",
+]);
+
+export function profileMajor(profile: string | undefined): "0.1" | "0.2" | "0.3" | null {
+  if (profile === undefined) return null;
+  const m = profile.match(/^sorane-okf\/(0\.[123])$/);
+  if (!m) return null;
+  return m[1] as "0.1" | "0.2" | "0.3";
+}
+
+export function isProfile03(profile: string | undefined): boolean {
+  return profile === "sorane-okf/0.3";
+}
+
+export function resolveProfileForValidation(
+  profile: string | undefined,
+): string {
+  if (profile !== undefined && SUPPORTED_PROFILE_RE.test(profile)) {
+    return profile;
+  }
+  return DEFAULT_PROFILE;
+}
+
+/** Build/validate effective type (0.3 unknown types → article). */
+export function resolveEffectiveType(
+  type: string,
+  profile: string | undefined,
+): string {
+  if (!type) return "";
+  if (isProfile03(profile)) {
+    if (TYPES_03.has(type)) return type;
+    return "article";
+  }
+  return type;
+}
+
+export function isBuildableContentType(
+  type: string,
+  profile: string | undefined,
+): boolean {
+  const effective = resolveEffectiveType(type, profile);
+  return BUILDABLE_CONTENT_TYPES.has(effective);
+}

package/src/validate.ts

@@ -6,16 +6,19 @@ import { fileURLToPath } from "node:url";
 import { validateDisclosureFields } from "./digital-source-type.ts";
 import { extract } from "./extract.ts";
 import { normalizeConcept } from "./normalize.ts";
+import {
+  DEFAULT_PROFILE,
+  isProfile03,
+  resolveProfileForValidation,
+  SUPPORTED_PROFILE_RE,
+  TYPES_01_02,
+  TYPES_03,
+} from "./profile.ts";
 import { parseYaml } from "./yaml.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROFILE_SCHEMA_DIR = join(__dirname, "../profile");
 
-const SUPPORTED_PROFILE_RE = /^sorane-okf\/(0\.[12])$/;
-const DEFAULT_PROFILE = "sorane-okf/0.1";
-
-const SUPPORTED_TYPES = new Set(["article", "index"]);
-
 export interface ValidationIssue {
   readonly where: "structure" | "frontmatter" | "type" | "profile";
   readonly message: string;
@@ -39,7 +42,7 @@ export function validateProfileFormat(
   if (!SUPPORTED_PROFILE_RE.test(profile)) {
     return {
       where: "profile",
-      message: `Unsupported profile "${profile}"; supported: sorane-okf/0.1, sorane-okf/0.2`,
+      message: `Unsupported profile "${profile}"; supported: sorane-okf/0.1, sorane-okf/0.2, sorane-okf/0.3`,
     };
   }
   return null;
@@ -70,6 +73,37 @@ function slugFromPath(filePath: string): string {
   return base.replace(/\.md$/i, "");
 }
 
+function validateTypeForProfile(
+  type: string,
+  profile: string,
+  issues: ValidationIssue[],
+  warnings: string[],
+): void {
+  if (!type) {
+    issues.push({
+      where: "type",
+      message: "OKF 必須フィールド `type` がありません",
+    });
+    return;
+  }
+
+  if (isProfile03(profile)) {
+    if (!TYPES_03.has(type)) {
+      warnings.push(
+        `unknown type "${type}" (sorane-okf/0.3); build treats as article`,
+      );
+    }
+    return;
+  }
+
+  if (!TYPES_01_02.has(type)) {
+    issues.push({
+      where: "type",
+      message: `未サポートの type: ${type}（${profile} は article / index のみ）`,
+    });
+  }
+}
+
 /** 1 つの markdown ソースを sorane-okf プロファイルで検証する。 */
 export function validateSource(file: string, source: string): ValidationResult {
   const { frontmatter, body } = extract(source);
@@ -126,29 +160,24 @@ export function validateSource(file: string, source: string): ValidationResult {
   const concept = normalizeConcept(raw, body, slugFromPath(file));
   warnings.push(...concept.warnings);
 
-  if (!concept.type) {
-    issues.push({
-      where: "type",
-      message: "OKF 必須フィールド `type` がありません",
-    });
-  } else if (!SUPPORTED_TYPES.has(concept.type)) {
-    issues.push({
-      where: "type",
-      message: `未サポートの type: ${concept.type}（v0.1 は article / index のみ）`,
-    });
-  }
-
-  const profile =
+  const profile = resolveProfileForValidation(
     typeof concept.profile === "string" && SUPPORTED_PROFILE_RE.test(concept.profile)
       ? concept.profile
-      : DEFAULT_PROFILE;
+      : undefined,
+  );
+
+  validateTypeForProfile(concept.type, profile, issues, warnings);
 
   if (issues.every((i) => i.where !== "profile")) {
     const validate = getValidatorForProfile(profile);
+    const schemaType =
+      isProfile03(profile) && concept.type && !TYPES_03.has(concept.type)
+        ? "article"
+        : concept.type || "article";
     const fmForSchema: Record<string, unknown> = {
-      type: concept.type || "article",
       title: concept.title,
       ...concept.frontmatter,
+      type: schemaType,
     };
     if (concept.timestamp) fmForSchema.timestamp = concept.timestamp;
     if (concept.description) fmForSchema.description = concept.description;
@@ -167,7 +196,7 @@ export function validateSource(file: string, source: string): ValidationResult {
     }
   }
 
-  const strictDisclosure = profile === "sorane-okf/0.2";
+  const strictDisclosure = profile === "sorane-okf/0.2" || profile === "sorane-okf/0.3";
   const disclosure = validateDisclosureFields(concept.frontmatter, strictDisclosure);
   warnings.push(...disclosure.warnings);
   for (const d of disclosure.issues) {