@skmtc/core 0.0.222 → 0.0.223

package/package.json

@@ -1,20 +1,26 @@
 {
   "name": "@skmtc/core",
-  "version": "0.0.222",
+  "version": "0.0.223",
   "main": "./script/mod.js",
-  "module": "./esm/mod.js",
+  "types": "./types/mod.d.ts",
   "exports": {
     ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js"
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
     },
     "./settings": {
-      "import": "./esm/types/Settings.js",
-      "require": "./script/types/Settings.js"
+      "require": {
+        "types": "./types/types/Settings.d.ts",
+        "default": "./script/types/Settings.js"
+      }
     },
     "./clientSchema": {
-      "import": "./esm/schemas/client.js",
-      "require": "./script/schemas/client.js"
+      "require": {
+        "types": "./types/schemas/client.js",
+        "default": "./script/schemas/client.js"
+      }
     }
   },
   "scripts": {

package/esm/_dnt.polyfills.js

@@ -1,15 +0,0 @@
-// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
-if (!Object.hasOwn) {
-    Object.defineProperty(Object, "hasOwn", {
-        value: function (object, property) {
-            if (object == null) {
-                throw new TypeError("Cannot convert undefined or null to object");
-            }
-            return Object.prototype.hasOwnProperty.call(Object(object), property);
-        },
-        configurable: true,
-        enumerable: false,
-        writable: true,
-    });
-}
-export {};

package/esm/_dnt.shims.js

@@ -1,61 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-const dntGlobals = {
-    Deno,
-};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}

package/esm/context/CoreContext.js

@@ -1,242 +0,0 @@
-import { GenerateContext } from './GenerateContext.js';
-import { match } from 'ts-pattern';
-import { RenderContext } from './RenderContext.js';
-export class CoreContext {
-    constructor({ phase }) {
-        Object.defineProperty(this, "phase", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.phase = phase;
-    }
-    setupGeneratePhase({ schemaModel, settings, generatorsMap }) {
-        const generateContext = new GenerateContext({
-            schemaModel,
-            settings,
-            generatorsMap
-        });
-        this.phase = { type: 'generate', context: generateContext };
-    }
-    setupRenderPhase({ files, prettier, packageDependencies, settings, renderDependencies, pinnableGenerators }) {
-        console.log('Render dependencies: ', renderDependencies);
-        const renderContext = new RenderContext({
-            files,
-            renderDependencies,
-            packageDependencies,
-            prettier,
-            settings,
-            pinnableGenerators
-        });
-        this.phase = { type: 'render', context: renderContext };
-    }
-    register({ destinationPath, ...args }) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.register({ destinationPath, ...args });
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot register during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot register during render phase`);
-        })
-            .exhaustive();
-    }
-    addGeneratorKey({ generatorKey }) {
-        return match(this.phase)
-            .with({ type: 'generate' }, () => {
-            console.log('trying to add generator key during generate phase');
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot add generator key during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => {
-            return context.addGeneratorKey({ generatorKey });
-        })
-            .exhaustive();
-    }
-    resolveSchemaRefOnce(refName) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.resolveSchemaRefOnce(refName);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot resolve schema during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot resolve schema during render phase`);
-        })
-            .exhaustive();
-    }
-    addRenderDependency(args) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.addRenderDependency(args);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot add render dependency during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot add render dependency during render phase`);
-        })
-            .exhaustive();
-    }
-    getFile(filePath) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.getFile(filePath);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot get file during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot get file during render phase`);
-        })
-            .exhaustive();
-    }
-    pick(args) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.pick(args))
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot pick during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => context.pick(args))
-            .exhaustive();
-    }
-    async render(options) {
-        return await match(this.phase)
-            .with({ type: 'generate' }, () => {
-            throw new Error(`Cannot render during generate phase`);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot render during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => context.render(options))
-            .exhaustive();
-    }
-    addFile(normalisedPath) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.addFile(normalisedPath);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot add file during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot add file during render phase`);
-        })
-            .exhaustive();
-    }
-    getOperationBaseSettings(args) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.getOperationBaseSettings(args);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access operation settings during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access operation settings during render phase`);
-        })
-            .exhaustive();
-    }
-    transform(args) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.transform({ ...args, coreContext: this });
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot run 'transform' during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot run 'transform' during render phase`);
-        })
-            .exhaustive();
-    }
-    getModelBaseSettings(args) {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => {
-            return context.getModelBaseSettings(args);
-        })
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access model settings during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access model settings during render phase`);
-        })
-            .exhaustive();
-    }
-    get files() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.files)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access files during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => context.files)
-            .exhaustive();
-    }
-    get renderDependencies() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.renderDependencies)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access files during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => context.renderDependencies)
-            .exhaustive();
-    }
-    get packageDependencies() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.packageDependencies)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access package dependencies during parse phase`);
-        })
-            .with({ type: 'render' }, ({ context }) => context.packageDependencies)
-            .exhaustive();
-    }
-    get schemaModel() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.schemaModel)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access schema model during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access schema model during render phase`);
-        })
-            .exhaustive();
-    }
-    get generatorsMap() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.generatorsMap)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access schema model during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access schema model during render phase`);
-        })
-            .exhaustive();
-    }
-    get parsedDocument() {
-        return match(this.phase)
-            .with({ type: 'parse' }, ({ context }) => context.parsedDocument)
-            .with({ type: 'generate' }, () => {
-            throw new Error(`Cannot access parsed document during generate phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access parsed document during render phase`);
-        })
-            .exhaustive();
-    }
-    get settings() {
-        return match(this.phase)
-            .with({ type: 'generate' }, ({ context }) => context.settings)
-            .with({ type: 'parse' }, () => {
-            throw new Error(`Cannot access settings during parse phase`);
-        })
-            .with({ type: 'render' }, () => {
-            throw new Error(`Cannot access settings during render phase`);
-        })
-            .exhaustive();
-    }
-}

package/esm/context/GenerateContext.js

@@ -1,173 +0,0 @@
-import { join, normalize } from '../deps/jsr.io/@std/path/1.0.0/mod.js';
-import { Import } from '../dsl/Import.js';
-import { toOperationGeneratorKey } from '../types/GeneratorKeys.js';
-import { OperationDriver } from '../dsl/OperationDriver.js';
-import { ModelDriver } from '../dsl/ModelDriver.js';
-export class GenerateContext {
-    constructor({ schemaModel, generatorsMap, settings }) {
-        Object.defineProperty(this, "files", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "renderDependencies", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "packageDependencies", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "schemaModel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "settings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "generatorsMap", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.generatorsMap = generatorsMap;
-        this.files = new Map();
-        this.renderDependencies = new Map();
-        this.packageDependencies = new Map();
-        this.schemaModel = schemaModel;
-        this.settings = settings;
-    }
-    getFile(filePath, { throwIfNotFound = false } = {}) {
-        const normalisedPath = normalize(filePath);
-        const currentFile = this.files.get(normalisedPath);
-        if (!currentFile) {
-            if (throwIfNotFound) {
-                throw new Error(`File not found: '${normalisedPath}'`);
-            }
-            else {
-                return this.addFile(normalisedPath);
-            }
-        }
-        return currentFile;
-    }
-    register({ imports = {}, packageDependencies = {}, definitions, destinationPath }) {
-        const currentFile = this.getFile(destinationPath);
-        Object.entries(imports).forEach(([importModule, importNames]) => {
-            const module = currentFile.imports.get(importModule);
-            const importItem = new Import({ module: importModule, importNames });
-            if (module) {
-                importItem.importNames.forEach(n => module.add(`${n}`));
-            }
-            else {
-                currentFile.imports.set(importModule, new Set(importItem.importNames.map(n => `${n}`)));
-            }
-        });
-        Object.entries(packageDependencies).forEach(([module, version]) => {
-            this.packageDependencies.set(module, version);
-        });
-        definitions
-            ?.filter((definition) => Boolean(definition))
-            .forEach(definition => {
-            currentFile.definitions.set(`${definition.identifier}`, definition);
-        });
-    }
-    transform({ coreContext, generation, destinationPath, ...rest }) {
-        if ('operation' in rest) {
-            const { creator, operation } = rest;
-            const { settings, definition } = new OperationDriver({
-                context: coreContext,
-                creator,
-                operation,
-                generation,
-                destinationPath
-            });
-            return { settings, definition };
-        }
-        else {
-            const { creator, refName } = rest;
-            const { settings, definition } = new ModelDriver({
-                context: coreContext,
-                creator,
-                refName,
-                generation,
-                destinationPath
-            });
-            return { settings, definition };
-        }
-    }
-    getOperationBaseSettings({ generatorId, path, method }) {
-        const generatorSettings = this.settings?.generators?.find(({ id }) => id === generatorId);
-        const operationSettings = generatorSettings && 'operations' in generatorSettings
-            ? generatorSettings.operations?.[path]?.[method]
-            : undefined;
-        const exportPath = operationSettings?.exportPath
-            ? join(generatorSettings?.exportPath ?? '', operationSettings?.exportPath)
-            : undefined;
-        const baseSettings = {
-            exportPath,
-            selected: Boolean(operationSettings?.selected),
-            name: operationSettings?.name,
-            importFrom: operationSettings?.importFrom
-        };
-        return baseSettings;
-    }
-    getModelBaseSettings({ generatorId, refName }) {
-        const generatorSettings = this.settings?.generators?.find(({ id }) => id === generatorId);
-        const modelSettings = generatorSettings && 'models' in generatorSettings
-            ? generatorSettings?.models?.[refName]
-            : undefined;
-        const exportPath = modelSettings?.exportPath
-            ? join(generatorSettings?.exportPath ?? '', modelSettings?.exportPath)
-            : undefined;
-        const baseSettings = {
-            exportPath,
-            selected: Boolean(modelSettings?.selected),
-            name: modelSettings?.name,
-            importFrom: modelSettings?.importFrom
-        };
-        return baseSettings;
-    }
-    addFile(normalisedPath) {
-        if (this.files.has(normalisedPath)) {
-            throw new Error(`File already exists: ${normalisedPath}`);
-        }
-        const newFile = {
-            imports: new Map(),
-            definitions: new Map(),
-            generatorKeys: new Set()
-        };
-        this.files.set(normalisedPath, newFile);
-        return newFile;
-    }
-    resolveSchemaRefOnce(refName) {
-        const schema = this.schemaModel.components?.schemas?.[refName]?.resolveOnce();
-        if (!schema) {
-            throw new Error(`Schema not found: ${refName}`);
-        }
-        return schema;
-    }
-    addRenderDependency({ generatorId, dependencies, operation }) {
-        if (!this.renderDependencies.has(generatorId)) {
-            this.renderDependencies.set(generatorId, new Set());
-        }
-        const generatorDependencies = this.renderDependencies.get(generatorId);
-        dependencies.forEach(dependencyId => {
-            generatorDependencies?.add(toOperationGeneratorKey({ generatorId: dependencyId, operation }));
-        });
-    }
-    /** Produce external instance and return its name */
-    pick({ name, exportPath }) {
-        return this.getFile(exportPath).definitions.get(name);
-    }
-}

package/esm/context/LogStore.js

@@ -1,53 +0,0 @@
-const LOG_LEVELS = {
-    info: 1,
-    warn: 3,
-    error: 5
-};
-export class LogStore {
-    constructor() {
-        Object.defineProperty(this, "logs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "operations", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-    }
-    addLog({ level, phase, trail, message }) {
-        const fullLog = `${level
-            .toUpperCase()
-            .padEnd(6)} [${phase.toUpperCase()}]  ${trail.toString()} - ${message}`;
-        this.logs.push(fullLog);
-        const { apiPath, method } = trail;
-        if (apiPath && method) {
-            const operationId = `${trail.method?.toUpperCase()} ${trail.apiPath}`;
-            if (!this.operations[operationId]) {
-                this.operations[operationId] = [];
-            }
-            const subMethodPath = `${trail.toSubMethodTrail().toString()}`;
-            const pathAndMessage = subMethodPath
-                ? `${subMethodPath} - ${message}`
-                : message;
-            const subMethodLog = `${level
-                .toUpperCase()
-                .padEnd(6)} [${phase.toUpperCase()}]  ${pathAndMessage}`;
-            this.operations[operationId].push(subMethodLog);
-        }
-    }
-    generateOutput() {
-        const logs = this.logs.join('\n');
-        const operations = Object.entries(this.operations).reduce((acc, [operation, logs]) => {
-            acc += `${operation}\n${logs.join('\n')}\n\n`;
-            return acc;
-        }, '');
-        return {
-            logs,
-            operations
-        };
-    }
-}

package/esm/context/ParseContext.js

@@ -1,18 +0,0 @@
-export class ParseContext {
-    constructor({ parsedDocument }) {
-        Object.defineProperty(this, "parsedDocument", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "refDiffs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.parsedDocument = parsedDocument;
-        this.refDiffs = [];
-    }
-}