@mirascript/typed 0.1.64 → 0.1.70

package/dist/type.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/type.peggy"],"names":["$top_level_initializer","Start","UnionType","PostfixType","PrimaryType","TypeParamList","TypeArgList","FunctionType","NamedFunction","FunctionBody","FunctionParamList","FunctionParam","RecordType","FieldList","Field","FieldName","HexDigit","EscapeSequence","String","DoubleQuotePart","SingleQuotePart","BacktickPart","DoubleQuoteChar","SingleQuoteChar","BacktickChar","Identifier","_","$initializer"],"mappings":"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","file":"type.js"}
+{"version":3,"sources":["../src/type.peggy"],"names":["$top_level_initializer","Start","UnionType","IntersectionType","PostfixType","PrimaryType","ReflectionType","TupleType","TupleElementList","TupleElement","TypeParamList","TypeArgList","FunctionType","NamedFunction","FunctionBody","FunctionParamList","FunctionParam","RecordType","FieldList","Field","FieldName","HexDigit","EscapeSequence","String","DoubleQuotePart","SingleQuotePart","BacktickPart","DoubleQuoteChar","SingleQuoteChar","BacktickChar","Identifier","_","$initializer"],"mappings":";;;;;AAAEA;AACFA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA2DoD;AACpD;AACI,G;sBAG2C;AAC/C;AACI,G;iCAOmC;AACvC;AACA;AACA;AACA;AACI,G;kCAUuD;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACI,G;wBACY;AAChB;AACA;AACI,G;yBAUsC;AAC1C;AACI,G;6BAOwC;AAC5C;AACI,G;iCAM0B;AAC9B;AACI,G;yBAkB0B,gBAAc,G;+BAGI;AAChD;AACA;AACA;AACI,G;6CAG0G;AAC9G;AACA;AACA;AACA;AACI,G;4BAGkD;AACtD;AACA;AACA;AACA;AACI,G;qCAGiD;AACrD;AACA;AACA;AACA;AACA;AACI,G;6BACoC;AACxC;AACI,G;4BAO+B,gCAA8B,G;kCAMnB;AAC9C;AACA;AACA;AACA;AACA;AACI,G;0BACW,oBAAkB,G;0BAIhB;AACjB;AACA;AACI,G;0BAU6B;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,G;yBAAoC;AACtC;AACA;AACA;AACA;AACE,G;yBAAiC;AACnC;AACA;AACA;AACA;AACA;AACA;AACE,G;2BAGkC,yBAAuB,G;2BACvB,yBAAuB,G;2BAC1B,yBAAuB,G;2BAI5B,mCAAiC,G;2BAIjC,mCAAiC,G;2BAIpC,mCAAiC,G;;;;;;;;;;;;;;;;;;;;;;;;;;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","file":"type.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirascript/typed",
-  "version": "0.1.64",
+  "version": "0.1.70",
   "author": "CloudPSS",
   "license": "MIT",
   "description": "Parse MiraScript type definitions and generate TypeScript types / JSON schemas.",
@@ -23,15 +23,16 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.1.1",
     "ava": "^8.0.1",
     "c8": "^11.0.0",
-    "js-yaml": "^5.2.0",
-    "peggy": "^5.1.0"
+    "js-yaml": "^5.2.1",
+    "peggy": "^5.1.0",
+    "@mirascript/mirascript": "~0.1.70"
   },
   "dependencies": {
-    "@types/json-schema": "^7.0.15",
-    "@mirascript/constants": "~0.1.64"
+    "json-schema-typed": "^8.0.2",
+    "@mirascript/constants": "~0.1.70"
   },
   "scripts": {
     "build": "peggy src/type.peggy --multi-output ./dist --dts --format es --source-map && tsc",

package/src/index.ts

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

package/src/json.ts

@@ -1,9 +1,12 @@
-import type { JSONSchema7 } from 'json-schema';
+import { type JSONSchema, $schema } from 'json-schema-typed';
 import { REG_NUMBER } from '@mirascript/constants';
+import { simplify } from './simplifier.js';
 import type { KnownType, LiteralType, NamedType, TemplateType, Type } from './parser.js';
 
+export type { JSONSchema } from 'json-schema-typed';
+
 /** Converts a KnownType or NamedType into JSON Schema */
-function string(type: KnownType | NamedType): JSONSchema7 {
+function string(type: KnownType | NamedType): JSONSchema {
     switch (type) {
         case 'string':
             return { type: 'string' };
@@ -14,19 +17,19 @@ function string(type: KnownType | NamedType): JSONSchema7 {
         case 'nil':
             return { type: 'null' };
         case 'array':
-            return { type: 'array' };
+            return { type: 'array', items: true };
         case 'record':
             return { type: 'object' };
         case 'extern':
-            return {};
+            return true;
         case 'any':
-            return {};
+            return true;
         case 'unknown':
-            return {};
+            return true;
         case 'never':
-            return {};
+            return false;
         default:
-            return {};
+            return true;
     }
 }
 
@@ -83,6 +86,9 @@ function templatePartPattern(part: Type, grouping: boolean): string {
                 result = `(${result})?`;
             }
         }
+    } else if (part.kind === 'intersection') {
+        // Regex intersection is not representable in general; keep behavior conservative.
+        result = RE_ANY;
     } else {
         result = RE_ANY;
     }
@@ -104,27 +110,21 @@ function templatePattern(type: TemplateType): string {
 }
 
 /** 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 };
+function literal(type: LiteralType): JSONSchema {
+    return { 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!;
-    }
+function literalEnum(types: LiteralType[]): JSONSchema {
+    const schema: JSONSchema = {
+        enum: types.map((t) => t.value),
+    };
     return schema;
 }
 
 /** Type guard for LiteralType */
 function isLiteralType(type: Type): type is LiteralType {
-    return typeof type === 'object' && type.kind === 'literal';
+    return typeof type == 'object' && type.kind === 'literal';
 }
 
 /** Options for toJSONSchema */
@@ -134,49 +134,67 @@ export interface ToJSONSchemaOptions {
 }
 
 /** Converts a Type object into JSON Schema */
-export function toJSONSchema(type: Type, options?: ToJSONSchemaOptions): JSONSchema7 {
-    const loose = options?.loose ?? false;
-    if (typeof type === 'symbol') {
+function toJSONSchemaImpl(type: Type, options: Required<ToJSONSchemaOptions>): JSONSchema {
+    const { loose } = options;
+    const simplified = simplify(type);
+    if (typeof simplified == 'symbol') {
         return {};
     }
-    if (typeof type === 'string') {
-        return string(type);
+    if (typeof simplified == 'string') {
+        return string(simplified);
     }
-    if (type.kind === 'array') {
+    if (simplified.kind === 'array') {
         return {
             type: 'array',
-            items: toJSONSchema(type.element, options),
+            items: toJSONSchemaImpl(simplified.element, options),
         };
     }
-    if (type.kind === 'union') {
-        const anyOf = [];
-        const literals = [];
-        for (const t of type.types) {
+    if (simplified.kind === 'union') {
+        const anyOf: JSONSchema[] = [];
+        const literals: LiteralType[] = [];
+        for (const t of simplified.types) {
             if (isLiteralType(t)) {
                 literals.push(t);
-            } else {
-                anyOf.push(toJSONSchema(t, options));
+                continue;
             }
+            const child = toJSONSchemaImpl(t, options);
+            if (child === true) {
+                return true;
+            }
+            if (child === false) {
+                continue;
+            }
+            anyOf.push(child);
         }
         if (literals.length > 0) {
             anyOf.push(literalEnum(literals));
         }
+        if (anyOf.length === 0) {
+            return false;
+        }
         if (anyOf.length === 1) {
             return anyOf[0]!;
         }
         return { anyOf };
     }
-    if (type.kind === 'record') {
-        if ('fields' in type) {
-            const properties: Record<string, JSONSchema7> = {};
+    if (simplified.kind === 'intersection') {
+        const allOf = simplified.types.map((t) => toJSONSchemaImpl(t, options));
+        if (allOf.length === 1) {
+            return allOf[0]!;
+        }
+        return { allOf };
+    }
+    if (simplified.kind === 'record') {
+        if ('fields' in simplified) {
+            const properties: Record<string, JSONSchema> = {};
             const required: string[] = [];
-            for (const field of type.fields) {
-                properties[field.name] = toJSONSchema(field.type, options);
+            for (const field of simplified.fields) {
+                properties[field.name] = toJSONSchemaImpl(field.type, options);
                 if (!field.optional && !loose) {
                     required.push(field.name);
                 }
             }
-            const schema: JSONSchema7 = {
+            const schema: JSONSchema = {
                 type: 'object',
                 properties,
                 additionalProperties: loose,
@@ -187,54 +205,119 @@ export function toJSONSchema(type: Type, options?: ToJSONSchemaOptions): JSONSch
             return schema;
         }
 
-        const valueSchema = toJSONSchema(type.value, options);
-        if (type.key == null) {
+        const valueSchema = toJSONSchemaImpl(simplified.value, options);
+        if (simplified.key == null) {
             return {
                 type: 'object',
                 additionalProperties: valueSchema,
             };
         }
-        if (typeof type.key == 'object') {
-            if (isLiteralType(type.key)) {
-                const schema: JSONSchema7 = {
+        if (typeof simplified.key == 'object') {
+            if (isLiteralType(simplified.key)) {
+                const schema: JSONSchema = {
                     type: 'object',
-                    properties: { [String(type.key.value)]: valueSchema },
+                    properties: { [String(simplified.key.value)]: valueSchema },
                     additionalProperties: loose,
                 };
                 return schema;
-            } else if (type.key.kind === 'union' && type.key.types.every(isLiteralType)) {
-                const schema: JSONSchema7 = {
+            } else if (simplified.key.kind === 'union' && simplified.key.types.every(isLiteralType)) {
+                const schema: JSONSchema = {
                     type: 'object',
-                    properties: Object.fromEntries(type.key.types.map((t) => [String(t.value), valueSchema])),
+                    properties: Object.fromEntries(simplified.key.types.map((t) => [String(t.value), valueSchema])),
                     additionalProperties: loose,
                 };
                 return schema;
             }
         }
-        const pattern = templatePartPattern(type.key, false);
+        const pattern = templatePartPattern(simplified.key, false);
         if (pattern === RE_ANY) {
             return {
                 type: 'object',
                 additionalProperties: valueSchema,
             };
         }
-        const schema: JSONSchema7 = {
+        const schema: JSONSchema = {
             type: 'object',
             patternProperties: { [`^${pattern}$`]: valueSchema },
             additionalProperties: loose,
         };
         return schema;
     }
-    if (type.kind === 'literal') {
-        return literal(type);
+    if (simplified.kind === 'literal') {
+        return literal(simplified);
     }
-    if (type.kind === 'function') {
-        return {};
+    if (simplified.kind === 'function') {
+        return false;
     }
-    if (type.kind === 'template') {
-        return { type: 'string', pattern: templatePattern(type) };
+    if (simplified.kind === 'template') {
+        return { type: 'string', pattern: templatePattern(simplified) };
+    }
+    if (simplified.kind === 'tuple') {
+        // Collect element schemas, unwrapping array from rest elements (..T[] → T).
+        // Non-array rest (e.g. ..string) is treated as any ({}).
+        const elementSchemas = simplified.elements.map((e) => {
+            const t = e.type;
+            if (!e.spread) return toJSONSchemaImpl(t, options);
+            if (typeof t == 'object' && t.kind === 'array') {
+                return toJSONSchemaImpl(t.element, options);
+            }
+            return true;
+        });
+
+        const prefixItems = [];
+        let i = 0;
+        for (; i < elementSchemas.length; i++) {
+            const el = simplified.elements[i]!;
+            if (el.spread) break;
+            prefixItems.push(elementSchemas[i]!);
+        }
+
+        const items = [];
+        let hasAny = false;
+        for (; i < elementSchemas.length; i++) {
+            const schema = elementSchemas[i]!;
+            items.push(schema);
+            if (schema === true) {
+                hasAny = true;
+            }
+        }
+
+        const schema: JSONSchema = { type: 'array' };
+        if (prefixItems.length > 0) {
+            schema.prefixItems = prefixItems;
+        }
+        if (hasAny) {
+            schema.items = true;
+        } else if (items.length > 1) {
+            schema.items = { anyOf: items };
+        } else if (items.length === 1) {
+            schema.items = items[0]!;
+        } else {
+            schema.items = loose;
+        }
+        return schema;
+    }
+    if (simplified.kind === 'reflection') {
+        return true;
     }
     /* c8 ignore next 3 */
-    (type) satisfies never;
-    return {};
+    simplified satisfies never;
+    return true;
+}
+
+/** Converts a Type object into JSON Schema */
+export function toJSONSchema(
+    type: Type,
+    options?: ToJSONSchemaOptions,
+): JSONSchema.Interface & { $schema: typeof $schema } {
+    let schema = toJSONSchemaImpl(type, { loose: options?.loose ?? false });
+    if (schema === true) {
+        schema = {};
+    } else if (schema === false) {
+        schema = { not: true };
+    }
+    return {
+        ...schema,
+        $schema,
+    };
 }

package/src/parser.ts

@@ -9,8 +9,11 @@ export type Type =
     | TemplateType
     | ArrayType
     | UnionType
+    | IntersectionType
     | RecordType
-    | FunctionType;
+    | FunctionType
+    | TupleType
+    | ReflectionType;
 
 /** Generic type parameter reference in MiraScript */
 export type GenericType = symbol;
@@ -46,6 +49,14 @@ export interface UnionType {
     types: Type[];
 }
 
+/** Intersection type in MiraScript */
+export interface IntersectionType {
+    /** Tag */
+    kind: 'intersection';
+    /** Types in the intersection */
+    types: Type[];
+}
+
 /** Array type in MiraScript */
 export interface ArrayType {
     /** Tag */
@@ -105,6 +116,30 @@ export interface FunctionParameter {
     spread?: boolean;
 }
 
+/** Tuple type in MiraScript */
+export interface TupleType {
+    /** Tag */
+    kind: 'tuple';
+    /** Elements in the tuple */
+    elements: TupleElement[];
+}
+
+/** Tuple element in MiraScript */
+export interface TupleElement {
+    /** Element type */
+    type: Type;
+    /** Whether the element is a rest element */
+    spread?: boolean;
+}
+
+/** Reflection type in MiraScript */
+export interface ReflectionType {
+    /** Tag */
+    kind: 'reflection';
+    /** The name of the variable being reflected */
+    name: string;
+}
+
 /**
  * Replaces generic type parameter names in the AST with unique symbols,
  * scoped per function declaration.
@@ -136,6 +171,10 @@ function resolveGenerics(type: Type, scope = new Map<string, GenericType>()): Ty
         type.types = type.types.map((t) => resolveGenerics(t, scope));
         return type;
     }
+    if (type.kind === 'intersection') {
+        type.types = type.types.map((t) => resolveGenerics(t, scope));
+        return type;
+    }
     if (type.kind === 'record') {
         if ('fields' in type) {
             for (const field of type.fields) {
@@ -154,6 +193,15 @@ function resolveGenerics(type: Type, scope = new Map<string, GenericType>()): Ty
         type.parts = type.parts.map((part) => resolveGenerics(part, scope));
         return type;
     }
+    if (type.kind === 'tuple') {
+        for (const element of type.elements) {
+            element.type = resolveGenerics(element.type, scope);
+        }
+        return type;
+    }
+    if (type.kind === 'reflection') {
+        return type;
+    }
     /* c8 ignore next 3 */
     (type) satisfies never;
     return type;