@intrig/plugin-sdk 0.0.1 → 0.0.2-2

package/dist/index.cjs

@@ -0,0 +1,471 @@
+'use strict';
+
+var prettier = require('prettier');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var prettier__namespace = /*#__PURE__*/_interopNamespaceDefault(prettier);
+
+class StatsCounter {
+    constructor(sourceId){
+        this.sourceId = sourceId;
+        this.counters = {};
+    }
+    inc(key) {
+        this.counters[key] = (this.counters[key] || 0) + 1;
+    }
+}
+
+function jsonLiteral(path) {
+    return async (strings, ...values)=>{
+        const rawCode = strings.reduce((acc, str, i)=>acc + str + (values[i] || ''), '');
+        const content = await prettier__namespace.format(rawCode, {
+            parser: 'json',
+            singleQuote: true
+        });
+        return {
+            path,
+            content
+        };
+    };
+}
+
+function getVariableName(ref) {
+    return ref.split('/').pop();
+}
+function getVariableImports(variables, source, prefix) {
+    return variables.map((a)=>getVariableName(a.ref)).map((ref)=>`import { ${ref} } from "${prefix}/${source}/components/schemas/${ref}.js"`).join("\n");
+}
+function getVariableTypes(variables) {
+    return variables.map((p)=>`${p.name}${p.in === "path" ? "" : "?"}: ${getVariableName(p.ref)}`).join("\n");
+}
+function isParamMandatory(variables) {
+    return variables.some((a)=>a.in === 'path');
+}
+function getParamExplodeExpression(variables) {
+    return [
+        ...variables.filter((a)=>a.in === "path").map((a)=>a.name),
+        "...params"
+    ].join(",");
+}
+function decodeVariables(_variables, source, prefix = "@root") {
+    const variables = _variables.filter((a)=>[
+            "path",
+            "query"
+        ].includes(a.in));
+    return {
+        variableImports: getVariableImports(variables, source, prefix),
+        variableTypes: getVariableTypes(variables),
+        isParamMandatory: isParamMandatory(variables),
+        variableExplodeExpression: getParamExplodeExpression(variables)
+    };
+}
+function getDispatchParams(operationId, requestBody, isParamMandatory = false) {
+    return [
+        requestBody ? `data: RequestBody` : undefined,
+        `params: Params${isParamMandatory ? '' : ' | undefined'}`
+    ].filter(Boolean).join(', ');
+}
+function getDispatchParamExpansion(requestBody, isParamMandatory) {
+    return [
+        requestBody && 'data',
+        `p${isParamMandatory ? '' : ' = {}'}`
+    ].filter(Boolean).join(', ');
+}
+function extractParams(properties) {
+    const paramMandatory = isParamMandatory(properties.variables ?? []);
+    if (properties.response) {
+        if (properties.requestBody) {
+            if (paramMandatory) {
+                return {
+                    shape: `BinaryFunctionHook<Params, RequestBody, Response, _ErrorType>`,
+                    shapeImport: `BinaryFunctionHook`,
+                    dispatchParamExpansion: `data, p`,
+                    dispatchParams: "data: RequestBody, params: Params"
+                };
+            } else {
+                return {
+                    shape: `BinaryFunctionHook<Params, RequestBody, Response, _ErrorType>`,
+                    shapeImport: `BinaryFunctionHook`,
+                    dispatchParamExpansion: `data, p = {}`,
+                    dispatchParams: "data: RequestBody, params?: Params"
+                };
+            }
+        } else {
+            if (paramMandatory) {
+                return {
+                    shape: `UnaryFunctionHook<Params, Response, _ErrorType>`,
+                    shapeImport: `UnaryFunctionHook`,
+                    dispatchParamExpansion: `p`,
+                    dispatchParams: "params: Params"
+                };
+            } else {
+                return {
+                    shape: `UnaryFunctionHook<Params, Response, _ErrorType>`,
+                    shapeImport: `UnaryFunctionHook`,
+                    dispatchParamExpansion: `p = {}`,
+                    dispatchParams: "params?: Params"
+                };
+            }
+        }
+    } else {
+        if (properties.requestBody) {
+            if (paramMandatory) {
+                return {
+                    shape: `BinaryProduceHook<Params, RequestBody, _ErrorType>`,
+                    shapeImport: `BinaryProduceHook`,
+                    dispatchParamExpansion: `data, p`,
+                    dispatchParams: "data: RequestBody, params: Params"
+                };
+            } else {
+                return {
+                    shape: `BinaryProduceHook<Params, RequestBody, _ErrorType>`,
+                    shapeImport: `BinaryProduceHook`,
+                    dispatchParamExpansion: `data, p = {}`,
+                    dispatchParams: "data: RequestBody, params?: Params"
+                };
+            }
+        } else {
+            if (paramMandatory) {
+                return {
+                    shape: `UnaryProduceHook<Params, _ErrorType>`,
+                    shapeImport: `UnaryProduceHook`,
+                    dispatchParamExpansion: `p`,
+                    dispatchParams: "params: Params"
+                };
+            } else {
+                return {
+                    shape: `UnaryProduceHook<Params, _ErrorType>`,
+                    shapeImport: `UnaryProduceHook`,
+                    dispatchParamExpansion: `p = {}`,
+                    dispatchParams: "params?: Params"
+                };
+            }
+        }
+    }
+}
+function decodeDispatchParams(operationId, requestBody, isParamMandatory) {
+    return {
+        dispatchParams: getDispatchParams(operationId, requestBody, isParamMandatory),
+        dispatchParamExpansion: getDispatchParamExpansion(requestBody, isParamMandatory)
+    };
+}
+function getDataTransformer(contentType) {
+    let finalRequestBodyBlock = 'data';
+    switch(contentType){
+        case "application/json":
+        case "application/octet-stream":
+        case "text/plain":
+            finalRequestBodyBlock = `data`;
+            break;
+        case "multipart/form-data":
+            finalRequestBodyBlock = `data: (function(){
+        let formData = new FormData()
+        Object.entries(data).filter(a => !!a[1]).forEach(([key, value]) => formData.append(key, value))
+        return formData;
+      })()`;
+            break;
+        case "application/x-www-form-urlencoded":
+            finalRequestBodyBlock = `data: qs.stringify(data)`;
+            break;
+    }
+    return finalRequestBodyBlock;
+}
+const contentTypePostfixMap = {
+    'application/json': undefined,
+    'multipart/form-data': 'form',
+    'application/octet-stream': 'binary',
+    'application/x-www-form-urlencoded': 'form',
+    'application/xml': 'xml',
+    'text/plain': 'txt',
+    'text/html': 'html',
+    'text/css': 'css',
+    'text/javascript': 'js'
+};
+function generatePostfix(contentType, responseType) {
+    return [
+        contentType && contentTypePostfixMap[contentType] ? `$${contentTypePostfixMap[contentType]}` : undefined,
+        responseType && contentTypePostfixMap[responseType] ? `_${contentTypePostfixMap[responseType]}` : undefined
+    ].filter(Boolean).join('');
+}
+function decodeErrorSections(errorResponses, source, prefix = '@root') {
+    const errorTypes = Array.from(new Set(Object.values(errorResponses ?? {}).map((a)=>a.response)));
+    const imports = errorTypes.map((ref)=>`import {${ref}, ${ref}Schema } from "${prefix}/${source}/components/schemas/${ref}.js"`).join('\n');
+    let schemaValidation = "z.any()";
+    switch(errorTypes.length){
+        case 0:
+            schemaValidation = "z.any()";
+            break;
+        case 1:
+            schemaValidation = `${errorTypes[0]}Schema`;
+            break;
+        default:
+            schemaValidation = `z.union([${errorTypes.map((a)=>`${a}Schema`).join(', ')}])`;
+    }
+    const s = errorTypes.join(' | ');
+    const def = `${s.trim().length ? s : 'any'}`;
+    return {
+        imports,
+        def,
+        schemaValidation
+    };
+}
+
+function mdLiteral(path) {
+    return async (strings, ...values)=>{
+        let rawCode = strings.reduce((acc, str, i)=>acc + str + (values[i] || ''), '');
+        rawCode = rawCode.replace("<hint>", "<hint style='display:none'>");
+        const content = await prettier__namespace.format(rawCode, {
+            parser: 'markdown'
+        });
+        return {
+            path,
+            content
+        };
+    };
+}
+
+function typescript(path) {
+    return async (strings, ...values)=>{
+        const rawCode = strings.reduce((acc, str, i)=>{
+            if (str.startsWith("*/")) str = str.slice(2);
+            const [before] = str.split("/*!");
+            return acc + before + (values?.[i] || '');
+        }, '');
+        const content = await prettier__namespace.format(rawCode, {
+            parser: 'typescript',
+            singleQuote: true
+        });
+        return {
+            path,
+            content
+        };
+    };
+}
+
+// Regexps involved with splitting words in various case formats.
+const SPLIT_LOWER_UPPER_RE = /([a-z0-9])([A-Z])/g;
+const SPLIT_UPPER_UPPER_RE = /([A-Z])([A-Z][a-z])/g;
+// Used to iterate over the initial split result and separate numbers.
+const SPLIT_SEPARATE_NUMBER_RE = /(\d)[a-z]|([a-zA-Z])\d/g;
+// Regexp involved with stripping non-word characters from the result.
+const DEFAULT_STRIP_REGEXP = /[^a-zA-Z0-9]+/g;
+// The replacement value for splits.
+const SPLIT_REPLACE_VALUE = "$1\0$2";
+// The default characters to keep after transforming case.
+const DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+/**
+ * Split any cased input strings into an array of words.
+ */ function split(value) {
+    let result = value.trim();
+    result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    let start = 0;
+    let end = result.length;
+    // Trim the delimiter from around the output string.
+    while(result.charAt(start) === "\0")start++;
+    if (start === end) return [];
+    while(result.charAt(end - 1) === "\0")end--;
+    return result.slice(start, end).split(/\0/g);
+}
+/**
+ * Split the input string into an array of words, separating numbers.
+ */ function splitSeparateNumbers(value) {
+    const words = split(value);
+    for(let i = 0; i < words.length; i++){
+        const word = words[i];
+        const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+        if (match) {
+            const offset = match.index + (match[1] ?? match[2]).length;
+            words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+        }
+    }
+    return words;
+}
+/**
+ * Convert a string to space separated lower case (`foo bar`).
+ */ function noCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return prefix + words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
+}
+/**
+ * Convert a string to camel case (`fooBar`).
+ */ function camelCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+    return prefix + words.map((word, index)=>{
+        if (index === 0) return lower(word);
+        return transform(word, index);
+    }).join(options?.delimiter ?? "") + suffix;
+}
+/**
+ * Convert a string to pascal case (`FooBar`).
+ */ function pascalCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+    return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+/**
+ * Convert a string to pascal snake case (`Foo_Bar`).
+ */ function pascalSnakeCase(input, options) {
+    return capitalCase(input, {
+        delimiter: "_",
+        ...options
+    });
+}
+/**
+ * Convert a string to capital case (`Foo Bar`).
+ */ function capitalCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return prefix + words.map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+/**
+ * Convert a string to constant case (`FOO_BAR`).
+ */ function constantCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return prefix + words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
+}
+/**
+ * Convert a string to dot case (`foo.bar`).
+ */ function dotCase(input, options) {
+    return noCase(input, {
+        delimiter: ".",
+        ...options
+    });
+}
+/**
+ * Convert a string to kebab case (`foo-bar`).
+ */ function kebabCase(input, options) {
+    return noCase(input, {
+        delimiter: "-",
+        ...options
+    });
+}
+/**
+ * Convert a string to path case (`foo/bar`).
+ */ function pathCase(input, options) {
+    return noCase(input, {
+        delimiter: "/",
+        ...options
+    });
+}
+/**
+ * Convert a string to path case (`Foo bar`).
+ */ function sentenceCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return prefix + words.map((word, index)=>{
+        if (index === 0) return transform(word);
+        return lower(word);
+    }).join(options?.delimiter ?? " ") + suffix;
+}
+/**
+ * Convert a string to snake case (`foo_bar`).
+ */ function snakeCase(input, options) {
+    return noCase(input, {
+        delimiter: "_",
+        ...options
+    });
+}
+/**
+ * Convert a string to header case (`Foo-Bar`).
+ */ function trainCase(input, options) {
+    return capitalCase(input, {
+        delimiter: "-",
+        ...options
+    });
+}
+function lowerFactory(locale) {
+    return locale === false ? (input)=>input.toLowerCase() : (input)=>input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+    return locale === false ? (input)=>input.toUpperCase() : (input)=>input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+    return (word)=>`${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+    return (word, index)=>{
+        const char0 = word[0];
+        const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+        return initial + lower(word.slice(1));
+    };
+}
+function splitPrefixSuffix(input, options = {}) {
+    const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+    const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    let prefixIndex = 0;
+    let suffixIndex = input.length;
+    while(prefixIndex < input.length){
+        const char = input.charAt(prefixIndex);
+        if (!prefixCharacters.includes(char)) break;
+        prefixIndex++;
+    }
+    while(suffixIndex > prefixIndex){
+        const index = suffixIndex - 1;
+        const char = input.charAt(index);
+        if (!suffixCharacters.includes(char)) break;
+        suffixIndex = index;
+    }
+    return [
+        input.slice(0, prefixIndex),
+        splitFn(input.slice(prefixIndex, suffixIndex)),
+        input.slice(suffixIndex)
+    ];
+}
+
+exports.StatsCounter = StatsCounter;
+exports.camelCase = camelCase;
+exports.capitalCase = capitalCase;
+exports.constantCase = constantCase;
+exports.decodeDispatchParams = decodeDispatchParams;
+exports.decodeErrorSections = decodeErrorSections;
+exports.decodeVariables = decodeVariables;
+exports.dotCase = dotCase;
+exports.extractParams = extractParams;
+exports.generatePostfix = generatePostfix;
+exports.getDataTransformer = getDataTransformer;
+exports.getDispatchParamExpansion = getDispatchParamExpansion;
+exports.getDispatchParams = getDispatchParams;
+exports.getParamExplodeExpression = getParamExplodeExpression;
+exports.getVariableImports = getVariableImports;
+exports.getVariableName = getVariableName;
+exports.getVariableTypes = getVariableTypes;
+exports.isParamMandatory = isParamMandatory;
+exports.jsonLiteral = jsonLiteral;
+exports.kebabCase = kebabCase;
+exports.mdLiteral = mdLiteral;
+exports.noCase = noCase;
+exports.pascalCase = pascalCase;
+exports.pascalSnakeCase = pascalSnakeCase;
+exports.pathCase = pathCase;
+exports.sentenceCase = sentenceCase;
+exports.snakeCase = snakeCase;
+exports.split = split;
+exports.splitSeparateNumbers = splitSeparateNumbers;
+exports.trainCase = trainCase;
+exports.typescript = typescript;

package/dist/index.d.ts

@@ -1,7 +1 @@
-export * from './lib/plugin-sdk.js';
-export * from './lib/template/json-literal.js';
-export * from './lib/template/template-util.js';
-export * from './lib/template/md-literal.js';
-export * from './lib/template/ts-literal.js';
-export * from './lib/util/change-case.js';
-//# sourceMappingURL=index.d.ts.map
+export * from "./src/index";