@mirascript/typed 0.1.62

package/dist/type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["..\\src\\type.peggy"],"names":["Start","Type","UnionType","PostfixType","PrimaryType","RecordType","FieldList","Field","FieldName","String","Identifier","_","$initializer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAuBgB,aAAW,G;yBAOP;AACpB;AACI,G;gCAGuD;AAC3D;AACA;AACA;AACA;AACI,G;gCAC+C;AACnD;AACA;AACA;AACA;AACI,G;iCAQmC;AACvC;AACA;AACA;AACA;AACI,G;kCAOiD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACI,G;wBACY;AAChB;AACI,G;sBACoB;AACxB;AACI,G;qBAQW,sBAAoB,G;2BACD,0BAAwB,G;4BAGZ;AAC9C;AACI,G;kCAG0C;AAC9C;AACA;AACA;AACA;AACA;AACI,G;uBACQ;AACZ;AACA;AACA;AACI,G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAvFJA,cAAK;;;;;;;;;;;;;;;;;;WAOLC,aAAI;;;;;;;;;;;;;;WAKJC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmBTC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAYXC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuBXC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIVC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKTC,cAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAcLC,kBAAS;;;;;;;;;;;WAQTC,eAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAINC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGVC,UAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA9HAC;AACDA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA","file":"type.js"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mirascript/typed",
+  "version": "0.1.62",
+  "author": "CloudPSS",
+  "license": "MIT",
+  "description": "Parse MiraScript type definitions and generate TypeScript types / JSON schemas.",
+  "keywords": [
+    "mirascript",
+    "json-schema",
+    "types"
+  ],
+  "homepage": "https://mira.cloudpss.net",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CloudPSS/MiraScript.git",
+    "directory": "packages/typed"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "ava": "^8.0.1",
+    "js-yaml": "^5.1.0",
+    "peggy": "^5.1.0"
+  },
+  "dependencies": {
+    "@types/json-schema": "^7.0.15"
+  },
+  "scripts": {
+    "build": "peggy src/type.peggy --multi-output ./dist --dts --format es --source-map && tsc",
+    "clean": "rimraf dist",
+    "test": "ava --no-worker-threads"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './parser.js';
+export * from './json.js';

package/src/json.ts

@@ -0,0 +1,105 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { KnownType, LiteralType, NamedType, Type } from './parser.js';
+
+/** Converts a KnownType or NamedType into JSON Schema */
+function string(type: KnownType | NamedType): JSONSchema7 {
+    switch (type) {
+        case 'string':
+            return { type: 'string' };
+        case 'number':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'nil':
+            return { type: 'null' };
+        case 'array':
+            return { type: 'array' };
+        case 'record':
+            return { type: 'object' };
+        case 'extern':
+            return {};
+        case 'any':
+            return {};
+        case 'unknown':
+            return {};
+        case 'never':
+            return {};
+        default:
+            return {};
+    }
+}
+
+/** Converts a Type object into JSON Schema */
+export function toJSONSchema(type: Type): JSONSchema7 {
+    if (typeof type === 'string') {
+        return string(type);
+    }
+    if (type.kind === 'array') {
+        return {
+            type: 'array',
+            items: toJSONSchema(type.element),
+        };
+    }
+    if (type.kind === 'union') {
+        const literals = type.types.filter(isLiteralType);
+        if (literals.length === type.types.length) {
+            return literalEnum(literals);
+        }
+        return {
+            anyOf: type.types.map(toJSONSchema),
+        };
+    }
+    if (type.kind === 'record') {
+        if (type.value !== undefined) {
+            return {
+                type: 'object',
+                additionalProperties: toJSONSchema(type.value),
+            };
+        }
+        const properties: Record<string, JSONSchema7> = {};
+        const required: string[] = [];
+        for (const field of type.fields) {
+            properties[field.name] = toJSONSchema(field.type);
+            if (!field.optional) {
+                required.push(field.name);
+            }
+        }
+        const schema: JSONSchema7 = {
+            type: 'object',
+            properties,
+        };
+        if (required.length > 0) {
+            schema.required = required;
+        }
+        return schema;
+    }
+    if (type.kind === 'literal') {
+        return literal(type);
+    }
+    (type) satisfies never;
+    return {};
+}
+
+/** Converts a LiteralType into JSON Schema */
+function literal(type: LiteralType): JSONSchema7 {
+    if (typeof type.value === 'boolean') {
+        return { type: 'boolean', const: type.value };
+    }
+    return { type: 'string', const: type.value };
+}
+
+/** Converts a union of LiteralTypes into a single JSON Schema enum */
+function literalEnum(types: LiteralType[]): JSONSchema7 {
+    const values = types.map((t) => t.value);
+    const valueTypes = new Set(values.map((v) => (typeof v === 'boolean' ? 'boolean' : 'string')));
+    const schema: JSONSchema7 = { enum: values };
+    if (valueTypes.size === 1) {
+        schema.type = valueTypes.values().next().value!;
+    }
+    return schema;
+}
+
+/** Type guard for LiteralType */
+function isLiteralType(type: Type): type is LiteralType {
+    return typeof type === 'object' && type.kind === 'literal';
+}

package/src/parser.ts

@@ -0,0 +1,71 @@
+import { parse as _parse } from '../dist/type.js';
+
+/** MiraScript type */
+export type Type = KnownType | NamedType | LiteralType | ArrayType | UnionType | RecordType;
+
+/** Literal type in MiraScript */
+export interface LiteralType {
+    /** Tag */
+    kind: 'literal';
+    /** Literal value */
+    value: string | boolean;
+}
+
+/** Known type names in MiraScript */
+export type KnownType =
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'nil'
+    | 'array'
+    | 'record'
+    | 'extern'
+    | 'any'
+    | 'unknown'
+    | 'never';
+
+/** Named type in MiraScript */
+export type NamedType = string & Record<never, never>;
+
+/** Union type in MiraScript */
+export interface UnionType {
+    /** Tag */
+    kind: 'union';
+    /** Types in the union */
+    types: Type[];
+}
+
+/** Array type in MiraScript */
+export interface ArrayType {
+    /** Tag */
+    kind: 'array';
+    /** Element type */
+    element: Type;
+}
+
+/** Record type in MiraScript */
+export interface RecordType {
+    /** Tag */
+    kind: 'record';
+    /** Fields in the record */
+    fields: RecordField[];
+    /** Value type for record<T> */
+    value?: Type;
+}
+
+/** Record field in MiraScript */
+export interface RecordField {
+    /** Field name */
+    name: string;
+    /** Whether the field is optional */
+    optional?: boolean;
+    /** Field type */
+    type: Type;
+}
+
+/**
+ * Parses a type string into a Type object.
+ */
+export function parse(type: string): Type {
+    return _parse(type) as Type;
+}

package/src/type.peggy

@@ -0,0 +1,128 @@
+{
+function named(name) {
+  return name;
+}
+
+function array(element) {
+  return { kind: "array", element };
+}
+
+function union(types) {
+  if (types.length === 1) return types[0];
+  return { kind: "union", types };
+}
+
+function record(fields) {
+  for(let i = 0; i < fields.length; i++) {
+    fields[i].name ??= String(i);
+  }
+  return { kind: "record", fields };
+}
+}
+
+Start
+  = _ t:Type _ { return t; }
+
+///////////////////////////////////////////////////////////////////////////////
+// Type (union)
+///////////////////////////////////////////////////////////////////////////////
+
+Type
+  = head:UnionType {
+      return head;
+    }
+
+UnionType
+  = _ "|" _ first:PostfixType rest:(_ "|" _ PostfixType)* {
+      return union([
+        first,
+        ...rest.map(x => x[3])
+      ]);
+    }
+  / first:PostfixType rest:(_ "|" _ PostfixType)+ {
+      return union([
+        first,
+        ...rest.map(x => x[3])
+      ]);
+    }
+  / PostfixType
+
+///////////////////////////////////////////////////////////////////////////////
+// Array
+///////////////////////////////////////////////////////////////////////////////
+
+PostfixType
+  = base:PrimaryType suffix:("[]" _)* {
+      let t = base;
+      for (const _ of suffix)
+        t = array(t);
+      return t;
+    }
+
+///////////////////////////////////////////////////////////////////////////////
+// Primary
+///////////////////////////////////////////////////////////////////////////////
+
+PrimaryType
+  = name:Identifier generic:(_ "<" _ t:Type _ ">")? {
+      if (generic) {
+        const t = generic[3];
+        if (name === 'array') return array(t);
+        if (name === 'record') return { kind: "record", fields: [], value: t };
+      }
+      if (name === 'true') return { kind: "literal", value: true };
+      if (name === 'false') return { kind: "literal", value: false };
+      return named(name);
+    }
+  / lit:String {
+      return { kind: "literal", value: lit };
+    }
+  / "(" _ t:Type _ ")" {
+      return t;
+    }
+  / RecordType
+
+///////////////////////////////////////////////////////////////////////////////
+// Record
+///////////////////////////////////////////////////////////////////////////////
+
+RecordType
+  = "(" _ ")" { return record([]); } 
+  / "(" _ fields:FieldList _ ")" { return record(fields); }
+
+FieldList
+  = fields:Field|1.., _ "," _ | ( _ "," _ )? {
+      return fields;
+    }
+
+Field
+  = name:FieldName opt:("?"?) _ ":" _ t:Type {
+      return {
+        name,
+        optional: opt !== null,
+        type: t
+      };
+    }
+  / t:Type {
+      return {
+        type: t
+      };
+    }
+
+FieldName
+  = Identifier
+  / String
+
+///////////////////////////////////////////////////////////////////////////////
+// Lexer
+///////////////////////////////////////////////////////////////////////////////
+
+String
+  = '"' @$[^"]* '"'
+  / "'" @$[^']* "'"
+
+Identifier
+  = $([a-zA-Z_][a-zA-Z0-9_]*)
+
+_
+  = [ \t\r\n]*