@kubohiroya/turbowarp-structured-data 0.4.0 → 0.5.0

package/README.md

@@ -23,7 +23,7 @@ JSON and YAML input is limited to 256 KiB, nesting depth 64, and 50,000 values.
 ## Installation
 
 ```bash
-pnpm add --save-exact @kubohiroya/turbowarp-structured-data@0.4.0
+pnpm add --save-exact @kubohiroya/turbowarp-structured-data@0.5.0
 ```
 
 ## Quick start

package/dist/extension-manifest.json

@@ -1,5 +1,5 @@
 {
-  "formatVersion": 3,
+  "formatVersion": 2,
   "id": "kubohiroyastructureddata",
   "pathSegmentType": {
     "kind": "discriminatedUnion",
@@ -422,5 +422,6 @@
         "irOperation": "structuredData.toYaml"
       }
     }
-  ]
+  ],
+  "menus": []
 }

package/dist/structured-data.js

@@ -440,7 +440,7 @@
   	]
   };
   //#endregion
-  //#region ../turbowarp-named-data/dist/composition.js
+  //#region node_modules/.pnpm/@kubohiroya+turbowarp-named-data@0.1.0/node_modules/@kubohiroya/turbowarp-named-data/dist/composition.js
   var NAMED_DATA_REGISTRY_SYMBOL_KEY = "@kubohiroya/turbowarp-named-data/registry";
   var NAMED_DATA_REGISTRY_SYMBOL = Symbol.for(NAMED_DATA_REGISTRY_SYMBOL_KEY);
   var NAMED_DATA_NAMESPACE_PATTERN = /^[a-z][a-z0-9.-]{0,63}$/u;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-structured-data",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Named structured data with JSON/YAML codecs and deterministic path operations for TurboWarp.",
   "author": "Hiroya Kubo <hiroya@cuc.ac.jp>",
   "license": "MPL-2.0",
@@ -26,7 +26,6 @@
   "files": [
     "dist/",
     "docs/",
-    "schemas/",
     "src/",
     "templates/",
     "README.md",
@@ -58,7 +57,8 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.5",
-    "@kubohiroya/turbowarp-named-data": "github:kubohiroya/turbowarp-named-data#bc3be0e669f501479ef45877e5d06e27714184d2",
+    "@kubohiroya/turbowarp-extension-manifest": "0.3.0",
+    "@kubohiroya/turbowarp-named-data": "0.1.0",
     "@kubohiroya/vite-plugin-turbowarp-extension": "0.3.0",
     "@types/node": "^24.13.3",
     "eslint": "^9.39.5",

package/src/extension-types.json

@@ -0,0 +1,15 @@
+{
+  "pathSegmentType": {
+    "kind": "discriminatedUnion",
+    "variants": [
+      {"kind": "key", "valueType": "string"},
+      {"kind": "index", "valueType": "nonNegativeInteger"}
+    ]
+  },
+  "dataReferenceType": {
+    "kind": "named",
+    "scope": "target",
+    "lifetime": "untilProjectStop",
+    "valueType": "jsonValue"
+  }
+}

package/schemas/extension-manifest.schema.json

@@ -1,103 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/kubohiroya/turbowarp-structured-data/main/schemas/extension-manifest.schema.json",
-  "title": "TurboWarp Structured Data Compiler Manifest",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["formatVersion", "id", "pathSegmentType", "dataReferenceType", "blocks"],
-  "properties": {
-    "formatVersion": {"const": 3},
-    "id": {"type": "string", "pattern": "^[a-z0-9]+$"},
-    "pathSegmentType": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["kind", "variants"],
-      "properties": {
-        "kind": {"const": "discriminatedUnion"},
-        "variants": {
-          "type": "array",
-          "prefixItems": [
-            {"$ref": "#/$defs/keyPathSegment"},
-            {"$ref": "#/$defs/indexPathSegment"}
-          ],
-          "items": false,
-          "minItems": 2,
-          "maxItems": 2
-        }
-      }
-    },
-    "dataReferenceType": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["kind", "scope", "lifetime", "valueType"],
-      "properties": {
-        "kind": {"const": "named"},
-        "scope": {"const": "target"},
-        "lifetime": {"const": "untilProjectStop"},
-        "valueType": {"const": "jsonValue"}
-      }
-    },
-    "blocks": {
-      "type": "array",
-      "minItems": 1,
-      "items": {"$ref": "#/$defs/block"}
-    }
-  },
-  "$defs": {
-    "keyPathSegment": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["kind", "valueType"],
-      "properties": {"kind": {"const": "key"}, "valueType": {"const": "string"}}
-    },
-    "indexPathSegment": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["kind", "valueType"],
-      "properties": {"kind": {"const": "index"}, "valueType": {"const": "nonNegativeInteger"}}
-    },
-    "argument": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["id", "type"],
-      "properties": {
-        "id": {"type": "string", "minLength": 1},
-        "type": {"enum": ["STRING", "NUMBER", "BOOLEAN"]},
-        "normalizesTo": {"const": "pathSegments"},
-        "staticLiteral": {"type": "boolean"},
-        "minimum": {"type": "number"},
-        "maximum": {"type": "number"}
-      }
-    },
-    "server": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["supported", "irOperation"],
-      "properties": {
-        "supported": {"type": "boolean"},
-        "irOperation": {"type": "string", "pattern": "^structuredData\\.[A-Za-z][A-Za-z0-9]*$"}
-      }
-    },
-    "block": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["opcode", "blockType", "arguments", "resultType", "effect", "immutable", "errors", "server"],
-      "properties": {
-        "opcode": {"type": "string", "minLength": 1},
-        "blockType": {"enum": ["COMMAND", "REPORTER", "BOOLEAN", "LOOP"]},
-        "arguments": {"type": "array", "items": {"$ref": "#/$defs/argument"}},
-        "resultType": {"enum": ["json", "jsonText", "yamlText", "boolean", "number", "string", "void"]},
-        "effect": {"enum": ["pure", "immutable", "state", "control"]},
-        "immutable": {"type": "boolean"},
-        "errors": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": {
-            "enum": ["INVALID_JSON", "INVALID_YAML", "INVALID_NAME", "DATA_NOT_FOUND", "INVALID_PATH", "PATH_NOT_FOUND", "TYPE_MISMATCH", "INDEX_OUT_OF_RANGE", "ITERATION_LIMIT_EXCEEDED", "ITERATION_CONTEXT_REQUIRED", "PARSE_LIMIT_EXCEEDED"]
-          }
-        },
-        "server": {"$ref": "#/$defs/server"}
-      }
-    }
-  }
-}

package/src/extension-manifest.ts

@@ -1,176 +0,0 @@
-import type {Plugin} from 'vite';
-
-export const EXTENSION_MANIFEST_FORMAT_VERSION = 3 as const;
-
-export interface ExtensionManifestArgument {
-  id: string;
-  type: string;
-  normalizesTo?: 'pathSegments';
-  staticLiteral?: boolean;
-  minimum?: number;
-  maximum?: number;
-}
-
-export interface ExtensionManifestBlock {
-  opcode: string;
-  blockType: string;
-  arguments: ExtensionManifestArgument[];
-  resultType: string;
-  effect: 'pure' | 'immutable' | 'state' | 'control';
-  immutable: boolean;
-  errors: string[];
-  server: {supported: boolean; irOperation: string};
-}
-
-export interface ExtensionManifest {
-  formatVersion: typeof EXTENSION_MANIFEST_FORMAT_VERSION;
-  id: string;
-  pathSegmentType: {
-    kind: 'discriminatedUnion';
-    variants: Array<{kind: 'key' | 'index'; valueType: 'string' | 'nonNegativeInteger'}>;
-  };
-  dataReferenceType: {
-    kind: 'named';
-    scope: 'target';
-    lifetime: 'untilProjectStop';
-    valueType: 'jsonValue';
-  };
-  blocks: ExtensionManifestBlock[];
-}
-
-export interface ExtensionManifestPluginOptions {
-  id: string;
-  definitions: unknown;
-  fileName?: string;
-}
-
-export function createExtensionManifest(id: string, definitions: unknown): ExtensionManifest {
-  if (!/^[a-z0-9]+$/.test(id)) {
-    throw new TypeError('Extension manifest ID must contain only lowercase letters and numbers.');
-  }
-  const source = requireRecord(definitions, 'Block definitions');
-  if (!Array.isArray(source.blocks)) {
-    throw new TypeError('Block definitions must contain a blocks array.');
-  }
-  const seenOpcodes = new Set<string>();
-  const blocks = source.blocks.map((block, index) => {
-    const normalized = normalizeBlock(block, index);
-    if (seenOpcodes.has(normalized.opcode)) {
-      throw new TypeError(`Duplicate block opcode: ${normalized.opcode}`);
-    }
-    seenOpcodes.add(normalized.opcode);
-    return normalized;
-  });
-  return {
-    formatVersion: EXTENSION_MANIFEST_FORMAT_VERSION,
-    id,
-    pathSegmentType: {
-      kind: 'discriminatedUnion',
-      variants: [
-        {kind: 'key', valueType: 'string'},
-        {kind: 'index', valueType: 'nonNegativeInteger'}
-      ]
-    },
-    dataReferenceType: {
-      kind: 'named',
-      scope: 'target',
-      lifetime: 'untilProjectStop',
-      valueType: 'jsonValue'
-    },
-    blocks: blocks.sort((left, right) => compareIds(left.opcode, right.opcode))
-  };
-}
-
-export function serializeExtensionManifest(id: string, definitions: unknown): string {
-  return `${JSON.stringify(createExtensionManifest(id, definitions), null, 2)}\n`;
-}
-
-export function extensionManifestPlugin(options: ExtensionManifestPluginOptions): Plugin {
-  return {
-    name: 'extension-api-manifest',
-    apply: 'build',
-    enforce: 'post',
-    generateBundle() {
-      this.emitFile({
-        type: 'asset',
-        fileName: options.fileName ?? 'extension-manifest.json',
-        source: serializeExtensionManifest(options.id, options.definitions)
-      });
-    }
-  };
-}
-
-function normalizeBlock(value: unknown, index: number): ExtensionManifestBlock {
-  const block = requireRecord(value, `Block at index ${index}`);
-  const opcode = requireNonEmptyString(block.opcode, `Block at index ${index} opcode`);
-  const argumentRecord = requireRecord(block.arguments ?? {}, `Block ${opcode} arguments`);
-  const argumentsList = Object.entries(argumentRecord).map(([id, value]) => {
-    const argument = requireRecord(value, `Block ${opcode} argument ${id}`);
-    const result: ExtensionManifestArgument = {
-      id: requireNonEmptyString(id, `Block ${opcode} argument ID`),
-      type: requireNonEmptyString(argument.type, `Block ${opcode} argument ${id} type`)
-    };
-    if (argument.normalizesTo !== undefined) {
-      if (argument.normalizesTo !== 'pathSegments') {
-        throw new TypeError(`Block ${opcode} argument ${id} has an unknown normalized type.`);
-      }
-      result.normalizesTo = argument.normalizesTo;
-    }
-    if (argument.staticLiteral !== undefined) result.staticLiteral = requireBoolean(argument.staticLiteral, `${opcode}.${id}.staticLiteral`);
-    if (argument.minimum !== undefined) result.minimum = requireNumber(argument.minimum, `${opcode}.${id}.minimum`);
-    if (argument.maximum !== undefined) result.maximum = requireNumber(argument.maximum, `${opcode}.${id}.maximum`);
-    return result;
-  });
-  const server = requireRecord(block.server, `Block ${opcode} server contract`);
-  const effect = block.effect;
-  if (
-    effect !== 'pure' &&
-    effect !== 'immutable' &&
-    effect !== 'state' &&
-    effect !== 'control'
-  ) {
-    throw new TypeError(`Block ${opcode} must define a supported effect.`);
-  }
-  if (!Array.isArray(block.errors) || !block.errors.every((code) => typeof code === 'string')) {
-    throw new TypeError(`Block ${opcode} errors must be an array of strings.`);
-  }
-  return {
-    opcode,
-    blockType: requireNonEmptyString(block.blockType, `Block ${opcode} blockType`),
-    arguments: argumentsList.sort((left, right) => compareIds(left.id, right.id)),
-    resultType: requireNonEmptyString(block.resultType, `Block ${opcode} resultType`),
-    effect,
-    immutable: requireBoolean(block.immutable, `Block ${opcode} immutable`),
-    errors: [...block.errors],
-    server: {
-      supported: requireBoolean(server.supported, `Block ${opcode} server.supported`),
-      irOperation: requireNonEmptyString(server.irOperation, `Block ${opcode} server.irOperation`)
-    }
-  };
-}
-
-function requireRecord(value: unknown, label: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new TypeError(`${label} must be an object.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function requireNonEmptyString(value: unknown, label: string): string {
-  if (typeof value !== 'string' || value.length === 0) throw new TypeError(`${label} must be a non-empty string.`);
-  return value;
-}
-
-function requireBoolean(value: unknown, label: string): boolean {
-  if (typeof value !== 'boolean') throw new TypeError(`${label} must be a boolean.`);
-  return value;
-}
-
-function requireNumber(value: unknown, label: string): number {
-  if (typeof value !== 'number' || !Number.isFinite(value)) throw new TypeError(`${label} must be a finite number.`);
-  return value;
-}
-
-function compareIds(left: string, right: string): number {
-  return left < right ? -1 : left > right ? 1 : 0;
-}