@aeriajs/compiler 0.0.3 → 0.0.6

package/dist/compile.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFromFiles = exports.generateScaffolding = exports.parseAndCheck = void 0;
+const diagnostic_js_1 = require("./diagnostic.js");
+const lexer_js_1 = require("./lexer.js");
+const parser_js_1 = require("./parser.js");
+const semantic_js_1 = require("./semantic.js");
+const codegen_js_1 = require("./codegen.js");
+const path = __importStar(require("node:path"));
+const fsPromises = __importStar(require("node:fs/promises"));
+const parseAndCheck = async (sources) => {
+    const errors = [];
+    let errorCount = 0;
+    let ast;
+    for (const fileName in sources) {
+        diagnostic_js_1.Diagnostic.currentFile = fileName;
+        const { errors: lexerErrors, tokens } = (0, lexer_js_1.tokenize)(sources[fileName]);
+        const { errors: parserErrors, ast: currentAst } = (0, parser_js_1.parse)(Array.from(tokens));
+        const { errors: semanticErrors } = await (0, semantic_js_1.analyze)(currentAst);
+        errors.push(...lexerErrors.concat(parserErrors, semanticErrors));
+        errorCount += errors.length;
+        if (!ast) {
+            ast = currentAst;
+        }
+        else {
+            ast.collections.push(...currentAst.collections);
+            ast.contracts.push(...currentAst.contracts);
+            ast.functionsets.push(...currentAst.functionsets);
+        }
+    }
+    return {
+        success: errorCount === 0,
+        errors,
+        errorCount,
+        ast: ast,
+    };
+};
+exports.parseAndCheck = parseAndCheck;
+const generateScaffolding = async (options) => {
+    const directories = [path.join(options.outDir, 'collections')];
+    for (const dir of directories) {
+        await fsPromises.mkdir(dir, {
+            recursive: true,
+        });
+    }
+    return directories;
+};
+exports.generateScaffolding = generateScaffolding;
+const compileFromFiles = async (schemaDir, options) => {
+    const fileList = await fsPromises.readdir(schemaDir);
+    const sources = {};
+    for (const file of fileList) {
+        const fileContent = await fsPromises.readFile(`${schemaDir}/${file}`);
+        sources[file] = fileContent.toString();
+    }
+    const parsed = await (0, exports.parseAndCheck)(sources);
+    const emittedFiles = await (0, codegen_js_1.generateCode)(parsed.ast, options);
+    return {
+        ...parsed,
+        emittedFiles,
+    };
+};
+exports.compileFromFiles = compileFromFiles;

package/dist/compile.mjs

@@ -0,0 +1,57 @@
+"use strict";
+import { Diagnostic } from "./diagnostic.mjs";
+import { tokenize } from "./lexer.mjs";
+import { parse } from "./parser.mjs";
+import { analyze } from "./semantic.mjs";
+import { generateCode } from "./codegen.mjs";
+import * as path from "node:path";
+import * as fsPromises from "node:fs/promises";
+export const parseAndCheck = async (sources) => {
+  const errors = [];
+  let errorCount = 0;
+  let ast;
+  for (const fileName in sources) {
+    Diagnostic.currentFile = fileName;
+    const { errors: lexerErrors, tokens } = tokenize(sources[fileName]);
+    const { errors: parserErrors, ast: currentAst } = parse(Array.from(tokens));
+    const { errors: semanticErrors } = await analyze(currentAst);
+    errors.push(...lexerErrors.concat(parserErrors, semanticErrors));
+    errorCount += errors.length;
+    if (!ast) {
+      ast = currentAst;
+    } else {
+      ast.collections.push(...currentAst.collections);
+      ast.contracts.push(...currentAst.contracts);
+      ast.functionsets.push(...currentAst.functionsets);
+    }
+  }
+  return {
+    success: errorCount === 0,
+    errors,
+    errorCount,
+    ast
+  };
+};
+export const generateScaffolding = async (options) => {
+  const directories = [path.join(options.outDir, "collections")];
+  for (const dir of directories) {
+    await fsPromises.mkdir(dir, {
+      recursive: true
+    });
+  }
+  return directories;
+};
+export const compileFromFiles = async (schemaDir, options) => {
+  const fileList = await fsPromises.readdir(schemaDir);
+  const sources = {};
+  for (const file of fileList) {
+    const fileContent = await fsPromises.readFile(`${schemaDir}/${file}`);
+    sources[file] = fileContent.toString();
+  }
+  const parsed = await parseAndCheck(sources);
+  const emittedFiles = await generateCode(parsed.ast, options);
+  return {
+    ...parsed,
+    emittedFiles
+  };
+};

package/dist/diagnostic.d.ts

@@ -0,0 +1,8 @@
+import type { Location } from './token.js';
+export declare class Diagnostic extends Error {
+    message: string;
+    location: Location;
+    fileLocation: string | undefined;
+    static currentFile: string | undefined;
+    constructor(message: string, location?: Location, fileLocation?: string | undefined);
+}

package/dist/diagnostic.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Diagnostic = void 0;
+const emptyLocation = {
+    index: 0,
+    line: 0,
+    start: 0,
+    end: 0,
+};
+class Diagnostic extends Error {
+    message;
+    location;
+    fileLocation;
+    static currentFile;
+    constructor(message, location = emptyLocation, fileLocation = Diagnostic.currentFile) {
+        super();
+        this.message = message;
+        this.location = location;
+        this.fileLocation = fileLocation;
+    }
+}
+exports.Diagnostic = Diagnostic;

package/dist/diagnostic.mjs

@@ -0,0 +1,16 @@
+"use strict";
+const emptyLocation = {
+  index: 0,
+  line: 0,
+  start: 0,
+  end: 0
+};
+export class Diagnostic extends Error {
+  constructor(message, location = emptyLocation, fileLocation = Diagnostic.currentFile) {
+    super();
+    this.message = message;
+    this.location = location;
+    this.fileLocation = fileLocation;
+  }
+  static currentFile;
+}

package/dist/guards.d.ts

@@ -0,0 +1,3 @@
+import * as AST from './ast.js';
+export declare const isNativePropertyType: (value: string) => value is keyof typeof AST.PropertyType;
+export declare const isValidPropertyModifier: (value: string) => value is keyof typeof AST.PropertyModifiers;

package/dist/guards.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPropertyModifier = exports.isNativePropertyType = void 0;
+const AST = __importStar(require("./ast.js"));
+const isNativePropertyType = (value) => {
+    return value in AST.PropertyType;
+};
+exports.isNativePropertyType = isNativePropertyType;
+const isValidPropertyModifier = (value) => {
+    return value in AST.PropertyModifiers;
+};
+exports.isValidPropertyModifier = isValidPropertyModifier;

package/dist/guards.mjs

@@ -0,0 +1,8 @@
+"use strict";
+import * as AST from "./ast.mjs";
+export const isNativePropertyType = (value) => {
+  return value in AST.PropertyType;
+};
+export const isValidPropertyModifier = (value) => {
+  return value in AST.PropertyModifiers;
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ast.js';
+export * from './compile.js';
+export * from './parser.js';
+export * from './lexer.js';
+export * from './semantic.js';
+export * from './token.js';
+export * from './diagnostic.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ast.js"), exports);
+__exportStar(require("./compile.js"), exports);
+__exportStar(require("./parser.js"), exports);
+__exportStar(require("./lexer.js"), exports);
+__exportStar(require("./semantic.js"), exports);
+__exportStar(require("./token.js"), exports);
+__exportStar(require("./diagnostic.js"), exports);

package/dist/index.mjs

@@ -0,0 +1,8 @@
+"use strict";
+export * from "./ast.mjs";
+export * from "./compile.mjs";
+export * from "./parser.mjs";
+export * from "./lexer.mjs";
+export * from "./semantic.mjs";
+export * from "./token.mjs";
+export * from "./diagnostic.mjs";

package/dist/lexer.d.ts

@@ -0,0 +1,14 @@
+import { type Token } from './token.js';
+import { Diagnostic } from './diagnostic.js';
+export type Keyword = typeof COLLECTION_KEYWORDS[number] | typeof COLLECTION_ACTIONS_KEYWORDS[number] | typeof COLLECTION_SEARCH_KEYWORDS[number] | typeof CONTRACT_KEYWORDS[number] | typeof TOPLEVEL_KEYWORDS[number] | typeof MISC_KEYWORDS[number];
+export declare const COLLECTION_KEYWORDS: readonly ["actions", "filters", "form", "functions", "icon", "indexes", "individualActions", "owned", "presets", "properties", "required", "search", "table"];
+export declare const COLLECTION_ACTIONS_KEYWORDS: readonly ["ask", "button", "clearItem", "effect", "event", "fetchItem", "function", "icon", "label", "params", "query", "requires", "roles", "route", "selection", "setItem", "translate"];
+export declare const COLLECTION_SEARCH_KEYWORDS: readonly ["indexes", "placeholder", "exactMatches"];
+export declare const CONTRACT_KEYWORDS: readonly ["payload", "query", "response"];
+export declare const TOPLEVEL_KEYWORDS: readonly ["collection", "contract", "functionset"];
+export declare const MISC_KEYWORDS: readonly ["extends"];
+export declare const KEYWORDS: Keyword[];
+export declare const tokenize: (input: string) => {
+    tokens: Token[];
+    errors: Diagnostic[];
+};

package/dist/lexer.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = exports.KEYWORDS = exports.MISC_KEYWORDS = exports.TOPLEVEL_KEYWORDS = exports.CONTRACT_KEYWORDS = exports.COLLECTION_SEARCH_KEYWORDS = exports.COLLECTION_ACTIONS_KEYWORDS = exports.COLLECTION_KEYWORDS = void 0;
+const token_js_1 = require("./token.js");
+const diagnostic_js_1 = require("./diagnostic.js");
+exports.COLLECTION_KEYWORDS = [
+    'actions',
+    'filters',
+    'form',
+    'functions',
+    'icon',
+    'indexes',
+    'individualActions',
+    'owned',
+    'presets',
+    'properties',
+    'required',
+    'search',
+    'table',
+];
+exports.COLLECTION_ACTIONS_KEYWORDS = [
+    'ask',
+    'button',
+    'clearItem',
+    'effect',
+    'event',
+    'fetchItem',
+    'function',
+    'icon',
+    'label',
+    'params',
+    'query',
+    'requires',
+    'roles',
+    'route',
+    'selection',
+    'setItem',
+    'translate',
+];
+exports.COLLECTION_SEARCH_KEYWORDS = [
+    'indexes',
+    'placeholder',
+    'exactMatches',
+];
+exports.CONTRACT_KEYWORDS = [
+    'payload',
+    'query',
+    'response',
+];
+exports.TOPLEVEL_KEYWORDS = [
+    'collection',
+    'contract',
+    'functionset',
+];
+exports.MISC_KEYWORDS = ['extends'];
+exports.KEYWORDS = [].concat(exports.COLLECTION_KEYWORDS, exports.COLLECTION_ACTIONS_KEYWORDS, exports.COLLECTION_SEARCH_KEYWORDS, exports.CONTRACT_KEYWORDS, exports.TOPLEVEL_KEYWORDS, exports.MISC_KEYWORDS);
+const keywordsSet = new Set();
+for (const keyword of exports.KEYWORDS) {
+    keywordsSet.add(keyword);
+}
+const TOKENS = [
+    {
+        type: null,
+        matcher: /\r?[ \t]+/,
+    },
+    {
+        type: token_js_1.TokenType.LineBreak,
+        matcher: '\n',
+    },
+    {
+        type: token_js_1.TokenType.Comment,
+        matcher: '//',
+    },
+    {
+        type: token_js_1.TokenType.LeftBracket,
+        matcher: '{',
+    },
+    {
+        type: token_js_1.TokenType.RightBracket,
+        matcher: '}',
+    },
+    {
+        type: token_js_1.TokenType.LeftParens,
+        matcher: '(',
+    },
+    {
+        type: token_js_1.TokenType.RightParens,
+        matcher: ')',
+    },
+    {
+        type: token_js_1.TokenType.LeftSquareBracket,
+        matcher: '[',
+    },
+    {
+        type: token_js_1.TokenType.RightSquareBracket,
+        matcher: ']',
+    },
+    {
+        type: token_js_1.TokenType.Pipe,
+        matcher: '|',
+    },
+    {
+        type: token_js_1.TokenType.Comma,
+        matcher: ',',
+    },
+    {
+        type: token_js_1.TokenType.Range,
+        matcher: /(\d+\.\.\d*|\d*\.\.\d+)/g,
+        valueExtractor: (value) => {
+            const [, left, right] = value.match(/(\d*)\.\.(\d*)/);
+            return [
+                parseInt(left),
+                parseInt(right),
+            ];
+        },
+    },
+    {
+        type: token_js_1.TokenType.Dot,
+        matcher: '.',
+    },
+    {
+        type: token_js_1.TokenType.Number,
+        matcher: /[0-9]+(\.[0-9]+)?/,
+        construct: Number,
+    },
+    {
+        type: token_js_1.TokenType.Boolean,
+        matcher: [
+            'true',
+            'false',
+        ],
+        construct: Boolean,
+    },
+    {
+        type: token_js_1.TokenType.Keyword,
+        matcher: Array.from(keywordsSet),
+        condition: (state) => !state.inPropertiesStack.at(-1),
+    },
+    {
+        type: token_js_1.TokenType.MacroName,
+        matcher: /[a-zA-Z]([a-zA-Z0-9]|_)+\(/,
+        valueExtractor: (value) => value.slice(0, -1),
+    },
+    {
+        type: token_js_1.TokenType.Identifier,
+        matcher: /([a-zA-Z0-9]|_)+/,
+    },
+    {
+        type: token_js_1.TokenType.QuotedString,
+        matcher: /"([^"]+)"/,
+        valueExtractor: (value) => value.slice(1, -1),
+    },
+    {
+        type: token_js_1.TokenType.AttributeName,
+        matcher: /@[a-zA-Z0-9]+/,
+        valueExtractor: (value) => value.slice(1),
+    },
+];
+const tokenize = function (input) {
+    let index = 0, line = 1, start = 0, end = 0;
+    const tokens = [];
+    const errors = [];
+    const state = {
+        inPropertiesStack: [],
+    };
+    while (index < input.length) {
+        let hasMatch = false;
+        for (const { type, matcher, valueExtractor, construct, condition } of TOKENS) {
+            let value;
+            let token;
+            if (condition) {
+                if (!condition(state)) {
+                    continue;
+                }
+            }
+            if (typeof matcher === 'string') {
+                if (input.slice(index).startsWith(matcher)) {
+                    value = matcher;
+                }
+            }
+            else if (matcher instanceof RegExp) {
+                const currentMatcher = new RegExp(matcher.source, 'y');
+                currentMatcher.lastIndex = index;
+                const matched = currentMatcher.exec(input);
+                if (matched) {
+                    [value] = matched;
+                }
+            }
+            else {
+                const segment = input.slice(index, index + input.slice(index).search(/[ \t\n\{\}\(\)\[\]]/));
+                if (segment && matcher.includes(segment)) {
+                    value = segment;
+                }
+            }
+            if (value) {
+                let tokenValue;
+                const location = {
+                    index: index += value.length,
+                    line,
+                    end: end += value.length,
+                    start: start = end - value.length,
+                };
+                switch (type) {
+                    case null: break;
+                    case token_js_1.TokenType.LineBreak:
+                        line++;
+                        end = 0;
+                        start = 0;
+                        break;
+                    case token_js_1.TokenType.Comment: {
+                        while (input[index++] !== '\n') { }
+                        line++;
+                        break;
+                    }
+                    default: {
+                        if (valueExtractor) {
+                            tokenValue = construct
+                                ? construct(valueExtractor(value))
+                                : valueExtractor(value);
+                        }
+                        else {
+                            tokenValue = construct
+                                ? construct(value)
+                                : value;
+                        }
+                        token = {
+                            type,
+                            location,
+                            value: tokenValue,
+                        };
+                        switch (type) {
+                            case token_js_1.TokenType.LeftBracket: {
+                                const lastToken = tokens.at(-1);
+                                if (lastToken) {
+                                    if (lastToken.value === 'properties') {
+                                        state.inPropertiesStack.push(true);
+                                    }
+                                    else {
+                                        state.inPropertiesStack.push(false);
+                                    }
+                                }
+                                break;
+                            }
+                            case token_js_1.TokenType.RightBracket: {
+                                if (state.inPropertiesStack.length > 0) {
+                                    state.inPropertiesStack.pop();
+                                }
+                                break;
+                            }
+                        }
+                        tokens.push(token);
+                    }
+                }
+                hasMatch = true;
+            }
+        }
+        if (!hasMatch) {
+            index += input.slice(index).search(/[ \t\n\{\}\(\)\[\]]/);
+            errors.push(new diagnostic_js_1.Diagnostic('unexpected token', {
+                index,
+                line,
+                start,
+                end,
+            }));
+        }
+    }
+    return {
+        tokens,
+        errors,
+    };
+};
+exports.tokenize = tokenize;