prettier-plugin-sql-cst 0.18.0 → 0.19.1

package/dist/syntax/index.js

@@ -1,87 +1,60 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.indexMap = {
-    create_index_stmt: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), __spreadArray([
-            print.spaced([
-                "createKw",
-                "orReplaceKw",
-                "indexTypeKw",
-                "indexKw",
-                "concurrentlyKw",
-                "ifNotExistsKw",
-                "name",
-                "onKw",
-                "table",
-                "using",
-                "columns",
-            ])
-        ], print("clauses"), true)));
-    },
-    index_specification: function (print) {
-        return print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]);
-    },
-    index_include_clause: function (print) { return print.spaced(["includeKw", "columns"]); },
-    index_nulls_distinct_clause: function (print) { return print.spaced(["nullsDistinctKw"]); },
-    index_nulls_not_distinct_clause: function (print) {
-        return print.spaced(["nullsNotDistinctKw"]);
-    },
-    drop_index_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced([
-            "dropKw",
+import { group, join } from "../print_utils";
+export const indexMap = {
+    create_index_stmt: (print) => group(join(print.dynamicLine(), [
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
             "indexTypeKw",
             "indexKw",
             "concurrentlyKw",
-            "ifExistsKw",
-            "indexes",
+            "ifNotExistsKw",
+            "name",
             "onKw",
             "table",
-            "behaviorKw",
-        ]));
-    },
-    verbose_all_columns: function (print) { return print.spaced("allColumnsKw"); },
-    alter_index_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced(["alterKw", "indexKw", "ifExistsKw", "index"]),
-            print.dynamicLine(),
-            print("action"),
-        ]);
-    },
-    alter_index_all_in_tablespace_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced([
-                "alterIndexKw",
-                "allInTablespaceKw",
-                "tablespace",
-                "ownedBy",
-            ]),
-            print.dynamicLine(),
-            print("action"),
-        ]);
-    },
-    reindex_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced([
-            "reindexKw",
-            "options",
-            "targetKw",
-            "concurrentlyKw",
-            "name",
-        ]));
-    },
-    reindex_option_concurrently: function (print) {
-        return print.spaced(["concurrentlyKw", "value"]);
-    },
-    reindex_option_tablespace: function (print) { return print.spaced(["tablespaceKw", "name"]); },
-    reindex_option_verbose: function (print) { return print.spaced(["verboseKw", "value"]); },
+            "using",
+            "columns",
+        ]),
+        ...print("clauses"),
+    ])),
+    index_specification: (print) => print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]),
+    index_include_clause: (print) => print.spaced(["includeKw", "columns"]),
+    index_nulls_distinct_clause: (print) => print.spaced(["nullsDistinctKw"]),
+    index_nulls_not_distinct_clause: (print) => print.spaced(["nullsNotDistinctKw"]),
+    drop_index_stmt: (print) => group(print.spaced([
+        "dropKw",
+        "indexTypeKw",
+        "indexKw",
+        "concurrentlyKw",
+        "ifExistsKw",
+        "indexes",
+        "onKw",
+        "table",
+        "behaviorKw",
+    ])),
+    verbose_all_columns: (print) => print.spaced("allColumnsKw"),
+    alter_index_stmt: (print) => group([
+        print.spaced(["alterKw", "indexKw", "ifExistsKw", "index"]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    alter_index_all_in_tablespace_stmt: (print) => group([
+        print.spaced([
+            "alterIndexKw",
+            "allInTablespaceKw",
+            "tablespace",
+            "ownedBy",
+        ]),
+        print.dynamicLine(),
+        print("action"),
+    ]),
+    reindex_stmt: (print) => group(print.spaced([
+        "reindexKw",
+        "options",
+        "targetKw",
+        "concurrentlyKw",
+        "name",
+    ])),
+    reindex_option_concurrently: (print) => print.spaced(["concurrentlyKw", "value"]),
+    reindex_option_tablespace: (print) => print.spaced(["tablespaceKw", "name"]),
+    reindex_option_verbose: (print) => print.spaced(["verboseKw", "value"]),
 };

package/dist/syntax/insert.js

@@ -1,50 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.insertMap = {
-    insert_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print.dynamicLine(), print("clauses"))); },
-    insert_clause: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
-            node.columns ? (0, print_utils_1.indent)([print.dynamicLine(), print("columns")]) : [],
-        ]);
-    },
-    values_clause: function (print) {
-        return (0, print_utils_1.group)([print("valuesKw"), (0, print_utils_1.indent)([print.dynamicLine(), print("values")])]);
-    },
-    or_alternate_action: function (print) { return print.spaced(["orKw", "actionKw"]); },
-    default: function (print) { return print("defaultKw"); },
-    default_values: function (print) { return print.spaced("defaultValuesKw"); },
-    upsert_clause: function (print) {
-        return print.spaced(["onConflictKw", "conflictTarget", "where", "doKw", "action"]);
-    },
-    conflict_target_on_constraint: function (print) {
-        return print.spaced(["onConstraintKw", "constraint"]);
-    },
-    upsert_action_nothing: function (print) { return print("nothingKw"); },
-    upsert_action_update: function (print) {
-        return (0, print_utils_1.group)([
-            print("updateKw"),
-            (0, print_utils_1.indent)([
-                print.dynamicLine(),
-                (0, print_utils_1.join)(print.dynamicLine(), print(["set", "where"])),
-            ]),
-        ]);
-    },
-    row_alias_clause: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["asKw", "rowAlias"]),
-            node.columnAliases
-                ? (0, print_utils_1.indent)([print.dynamicLine(), print("columnAliases")])
-                : [],
-        ]);
-    },
-    on_duplicate_key_update_clause: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced("onDuplicateKeyUpdateKw"),
-            (0, print_utils_1.indent)([print.dynamicLine(), print("assignments")]),
-        ]);
-    },
-    overriding_clause: function (print) { return print.spaced("overridingKw"); },
+import { join, group, indent } from "../print_utils";
+export const insertMap = {
+    insert_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+    insert_clause: (print, node) => group([
+        print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
+        node.columns ? indent([print.dynamicLine(), print("columns")]) : [],
+    ]),
+    values_clause: (print) => group([print("valuesKw"), indent([print.dynamicLine(), print("values")])]),
+    or_alternate_action: (print) => print.spaced(["orKw", "actionKw"]),
+    default: (print) => print("defaultKw"),
+    default_values: (print) => print.spaced("defaultValuesKw"),
+    upsert_clause: (print) => print.spaced(["onConflictKw", "conflictTarget", "where", "doKw", "action"]),
+    conflict_target_on_constraint: (print) => print.spaced(["onConstraintKw", "constraint"]),
+    upsert_action_nothing: (print) => print("nothingKw"),
+    upsert_action_update: (print) => group([
+        print("updateKw"),
+        indent([
+            print.dynamicLine(),
+            join(print.dynamicLine(), print(["set", "where"])),
+        ]),
+    ]),
+    row_alias_clause: (print, node) => group([
+        print.spaced(["asKw", "rowAlias"]),
+        node.columnAliases
+            ? indent([print.dynamicLine(), print("columnAliases")])
+            : [],
+    ]),
+    on_duplicate_key_update_clause: (print) => group([
+        print.spaced("onDuplicateKeyUpdateKw"),
+        indent([print.dynamicLine(), print("assignments")]),
+    ]),
+    overriding_clause: (print) => print.spaced("overridingKw"),
 };

package/dist/syntax/merge.js

@@ -1,35 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.mergeMap = {
-    merge_stmt: function (print) { return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))); },
-    merge_clause: function (print) {
-        return (0, print_utils_1.join)(print_utils_1.line, [
-            print.spaced(["mergeKw", "intoKw", "target"]),
-            print.spaced(["usingKw", "source"]),
-            (0, print_utils_1.group)([print("onKw"), (0, print_utils_1.indent)([print_utils_1.line, print("condition")])]),
-        ]);
-    },
-    merge_when_clause: function (print, node) { return [
-        (0, print_utils_1.group)([
+import { group, hardline, indent, join, line } from "../print_utils";
+export const mergeMap = {
+    merge_stmt: (print) => group(join(hardline, print("clauses"))),
+    merge_clause: (print) => join(line, [
+        print.spaced(["mergeKw", "intoKw", "target"]),
+        print.spaced(["usingKw", "source"]),
+        group([print("onKw"), indent([line, print("condition")])]),
+    ]),
+    merge_when_clause: (print, node) => [
+        group([
             print.spaced(["whenKw", "matchedKw", "byKw"]),
-            node.condition ? (0, print_utils_1.indent)([print_utils_1.line, print("condition")]) : [],
-            [print_utils_1.line, print("thenKw")],
+            node.condition ? indent([line, print("condition")]) : [],
+            [line, print("thenKw")],
         ]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.group)(print("action"))]),
-    ]; },
-    merge_when_condition: function (print) { return print.spaced(["andKw", "expr"]); },
-    merge_action_delete: function (print) { return print("deleteKw"); },
-    merge_action_insert: function (print, node) { return [
-        (0, print_utils_1.group)([
+        indent([hardline, group(print("action"))]),
+    ],
+    merge_when_condition: (print) => print.spaced(["andKw", "expr"]),
+    merge_action_delete: (print) => print("deleteKw"),
+    merge_action_insert: (print, node) => [
+        group([
             print("insertKw"),
-            node.columns ? (0, print_utils_1.indent)([print_utils_1.hardline, print("columns")]) : [],
+            node.columns ? indent([hardline, print("columns")]) : [],
         ]),
-        print_utils_1.line,
-        (0, print_utils_1.join)(print_utils_1.hardline, print("clauses")),
-    ]; },
-    merge_action_insert_row_clause: function (print) { return print("rowKw"); },
-    merge_action_update: function (print) { return print.spaced(["updateKw", "set"]); },
-    merge_action_do_nothing: function (print) { return print.spaced(["doNothingKw"]); },
+        line,
+        join(hardline, print("clauses")),
+    ],
+    merge_action_insert_row_clause: (print) => print("rowKw"),
+    merge_action_update: (print) => print.spaced(["updateKw", "set"]),
+    merge_action_do_nothing: (print) => print.spaced(["doNothingKw"]),
 };

package/dist/syntax/other_clauses.js

@@ -1,18 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.otherClausesMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.otherClausesMap = {
+import { line, indent, group } from "../print_utils";
+export const otherClausesMap = {
     // CLUSTER BY clause
-    cluster_by_clause: function (print) {
-        return (0, print_utils_1.group)([print.spaced("clusterByKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
-    },
+    cluster_by_clause: (print) => group([print.spaced("clusterByKw"), indent([line, print("columns")])]),
     // RETURNING clause
-    returning_clause: function (print) {
-        return (0, print_utils_1.group)([print("returningKw"), (0, print_utils_1.indent)([print_utils_1.line, print("columns")])]);
-    },
+    returning_clause: (print) => group([print("returningKw"), indent([line, print("columns")])]),
     // WHERE CURRENT OF clause
-    where_current_of_clause: function (print) {
-        return print.spaced(["whereCurrentOfKw", "cursor"]);
-    },
+    where_current_of_clause: (print) => print.spaced(["whereCurrentOfKw", "cursor"]),
 };

package/dist/syntax/parameter.js

@@ -1,31 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parameterMap = void 0;
-var expr_1 = require("./expr");
-var print_utils_1 = require("../print_utils");
-exports.parameterMap = {
+import { printLiteral } from "./expr";
+import { group } from "../print_utils";
+export const parameterMap = {
     // SET
-    set_parameter_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["setKw", "modifierKw", "name", "operator", "value"]));
-    },
-    set_time_zone_parameter_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"]));
-    },
-    set_parameter_clause: function (print) {
-        return print.spaced(["setKw", "name", "operator", "value"]);
-    },
-    local_parameter_value: function (print) { return print("localKw"); },
-    set_parameter_from_current_clause: function (print) {
-        return print.spaced(["setKw", "name", "fromCurrentKw"]);
-    },
+    set_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "name", "operator", "value"])),
+    set_time_zone_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"])),
+    set_parameter_clause: (print) => print.spaced(["setKw", "name", "operator", "value"]),
+    local_parameter_value: (print) => print("localKw"),
+    set_parameter_from_current_clause: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
     // RESET
-    reset_parameter_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["resetKw", "name"])); },
-    reset_parameter_clause: function (print) { return print.spaced(["resetKw", "name"]); },
-    all_parameters: function (print) { return print("allKw"); },
+    reset_parameter_stmt: (print) => group(print.spaced(["resetKw", "name"])),
+    reset_parameter_clause: (print) => print.spaced(["resetKw", "name"]),
+    all_parameters: (print) => print("allKw"),
     // SHOW
-    show_parameter_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["showKw", "name"])); },
+    show_parameter_stmt: (print) => group(print.spaced(["showKw", "name"])),
     /** cst-ignore: value */
-    boolean_on_off_literal: function (print, node, path, options) {
-        return (0, expr_1.printLiteral)(node.valueKw, options);
-    },
+    boolean_on_off_literal: (print, node, path, options) => printLiteral(node.valueKw, options),
 };

package/dist/syntax/policy.js

@@ -1,42 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.policyMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.policyMap = {
-    create_policy_stmt: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["createPolicyKw", "name", "onKw", "table"]),
-            node.clauses.length > 0 ? print.dynamicLine() : [],
-            (0, print_utils_1.join)(print.dynamicLine(), print("clauses")),
-        ]);
-    },
-    policy_permissive_clause: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["asKw", "permissiveKw"]));
-    },
-    policy_restrictive_clause: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["asKw", "restrictiveKw"]));
-    },
-    policy_command_clause: function (print) { return (0, print_utils_1.group)(print.spaced(["forKw", "commandKw"])); },
-    policy_roles_clause: function (print) { return (0, print_utils_1.group)(print.spaced(["toKw", "roles"])); },
-    policy_using_clause: function (print) { return (0, print_utils_1.group)(print.spaced(["usingKw", "expr"])); },
-    policy_check_clause: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["withKw", "checkKw", "expr"]));
-    },
-    alter_policy_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced(["alterPolicyKw", "name", "onKw", "table"]),
-            print.dynamicLine(),
-            (0, print_utils_1.join)(print.dynamicLine(), print("actions")),
-        ]);
-    },
-    drop_policy_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced([
-            "dropPolicyKw",
-            "ifExistsKw",
-            "name",
-            "onKw",
-            "table",
-            "behaviorKw",
-        ]));
-    },
+import { group, join } from "../print_utils";
+export const policyMap = {
+    create_policy_stmt: (print, node) => group([
+        print.spaced(["createPolicyKw", "name", "onKw", "table"]),
+        node.clauses.length > 0 ? print.dynamicLine() : [],
+        join(print.dynamicLine(), print("clauses")),
+    ]),
+    policy_permissive_clause: (print) => group(print.spaced(["asKw", "permissiveKw"])),
+    policy_restrictive_clause: (print) => group(print.spaced(["asKw", "restrictiveKw"])),
+    policy_command_clause: (print) => group(print.spaced(["forKw", "commandKw"])),
+    policy_roles_clause: (print) => group(print.spaced(["toKw", "roles"])),
+    policy_using_clause: (print) => group(print.spaced(["usingKw", "expr"])),
+    policy_check_clause: (print) => group(print.spaced(["withKw", "checkKw", "expr"])),
+    alter_policy_stmt: (print) => group([
+        print.spaced(["alterPolicyKw", "name", "onKw", "table"]),
+        print.dynamicLine(),
+        join(print.dynamicLine(), print("actions")),
+    ]),
+    drop_policy_stmt: (print) => group(print.spaced([
+        "dropPolicyKw",
+        "ifExistsKw",
+        "name",
+        "onKw",
+        "table",
+        "behaviorKw",
+    ])),
 };

package/dist/syntax/prepared_statements.js

@@ -1,51 +1,31 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preparedStatementsMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.preparedStatementsMap = {
+import { group, hardline, indent, join, line } from "../print_utils";
+export const preparedStatementsMap = {
     // EXECUTE
-    execute_stmt: function (print, node) {
-        var _a;
-        if (((_a = node.args) === null || _a === void 0 ? void 0 : _a.type) === "execute_using_clause") {
-            return (0, print_utils_1.group)(print.spaced(["executeKw", "name", "args"]));
+    execute_stmt: (print, node) => {
+        if (node.args?.type === "execute_using_clause") {
+            return group(print.spaced(["executeKw", "name", "args"]));
         }
         else {
-            return (0, print_utils_1.group)([print.spaced(["executeKw", "name"]), print("args")]);
+            return group([print.spaced(["executeKw", "name"]), print("args")]);
         }
     },
-    execute_immediate_stmt: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(print_utils_1.hardline, __spreadArray([
-            (0, print_utils_1.group)([
-                print.spaced(["executeKw", "immediateKw"]),
-                (0, print_utils_1.indent)([print_utils_1.line, print("expr")]),
-            ])
-        ], print(["into", "using"]).map(function (clause) { return (0, print_utils_1.group)(clause); }), true)));
-    },
-    execute_into_clause: function (print) { return print.spaced(["intoKw", "variables"]); },
-    execute_using_clause: function (print) {
-        return (0, print_utils_1.group)([print("usingKw"), (0, print_utils_1.indent)([print_utils_1.line, print("values")])]);
-    },
+    execute_immediate_stmt: (print) => group(join(hardline, [
+        group([
+            print.spaced(["executeKw", "immediateKw"]),
+            indent([line, print("expr")]),
+        ]),
+        ...print(["into", "using"]).map((clause) => group(clause)),
+    ])),
+    execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
+    execute_using_clause: (print) => group([print("usingKw"), indent([line, print("values")])]),
     // PREPARE
-    prepare_stmt: function (print) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(" ", [
-            print("prepareKw"),
-            print(["name", "params"]),
-            print("source"),
-        ]));
-    },
-    prepare_from_clause: function (print) {
-        return (0, print_utils_1.group)([print("fromKw"), (0, print_utils_1.indent)([print_utils_1.line, print("expr")])]);
-    },
+    prepare_stmt: (print) => group(join(" ", [
+        print("prepareKw"),
+        print(["name", "params"]),
+        print("source"),
+    ])),
+    prepare_from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
     // DEALLOCATE
-    deallocate_stmt: function (print) { return (0, print_utils_1.group)(print.spaced(["deallocateKw", "name"])); },
-    deallocate_all: function (print) { return print("allKw"); },
+    deallocate_stmt: (print) => group(print.spaced(["deallocateKw", "name"])),
+    deallocate_all: (print) => print("allKw"),
 };

package/dist/syntax/proc_clause.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.procClauseMap = void 0;
-var node_utils_1 = require("../node_utils");
-var print_utils_1 = require("../print_utils");
-exports.procClauseMap = {
-    returns_clause: function (print) { return print.spaced(["returnsKw", "dataType"]); },
-    determinism_clause: function (print) { return print.spaced("deterministicKw"); },
-    language_clause: function (print) { return print.spaced(["languageKw", "name"]); },
-    as_clause: function (print, node) {
-        if ((0, node_utils_1.isStringLiteral)(node.expr) || (0, node_utils_1.isDynamicallyLoadedFunction)(node.expr)) {
+import { isDynamicallyLoadedFunction, isStringLiteral } from "../node_utils";
+import { hardline, indent } from "../print_utils";
+export const procClauseMap = {
+    returns_clause: (print) => print.spaced(["returnsKw", "dataType"]),
+    determinism_clause: (print) => print.spaced("deterministicKw"),
+    language_clause: (print) => print.spaced(["languageKw", "name"]),
+    as_clause: (print, node) => {
+        if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
             return print.spaced(["asKw", "expr"]);
         }
-        return [print("asKw"), (0, print_utils_1.indent)([print_utils_1.hardline, print("expr")])];
-    },
-    with_connection_clause: function (print) {
-        return print.spaced(["withConnectionKw", "connection"]);
+        return [print("asKw"), indent([hardline, print("expr")])];
     },
+    with_connection_clause: (print) => print.spaced(["withConnectionKw", "connection"]),
 };