derw
Version:
An Elm-inspired language that transpiles to TypeScript
286 lines (285 loc) • 9.32 kB
JavaScript
;
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.generateValue = generateValue;
exports.generateStringValue = generateStringValue;
exports.generateFormatStringValue = generateFormatStringValue;
exports.generateListRange = generateListRange;
exports.generateListDestructurePart = generateListDestructurePart;
exports.flattenLeftPipe = flattenLeftPipe;
exports.generateImportBlock = generateImportBlock;
exports.generateExportBlock = generateExportBlock;
const Utils_1 = require("../Utils");
const List = __importStar(require("../stdlib/List"));
function FunctionCall(args) {
return {
kind: "FunctionCall",
...args,
};
}
function LambdaCall(args) {
return {
kind: "LambdaCall",
...args,
};
}
function generateValue(value) {
return value.body;
}
function generateStringValue(string) {
return `"${string.body}"`;
}
function generateFormatStringValue(string) {
return "`" + string.body + "`";
}
function generateListRange(list) {
const gap = `${list.end.body} - ${list.start.body} + 1`;
return `Array.from({ length: ${gap} }, (_ReservedX, _ReservedI) => _ReservedI + ${list.start.body})`;
}
function generateListDestructurePart(part) {
switch (part.kind) {
case "EmptyList": {
return "[]";
}
case "StringValue": {
const { body } = part;
return body;
}
case "FormatStringValue": {
const { body } = part;
return body;
}
case "Value": {
const { body } = part;
return body;
}
case "Destructure": {
const { constructor, pattern } = part;
const generatedPattern = pattern ? ` ${pattern}` : "";
return `${constructor}${pattern}`;
}
}
}
function addArgsToModuleReference(moduleReference, newArgs) {
switch (moduleReference.value.kind) {
case "FunctionCall": {
const { args, name } = moduleReference.value;
return { ...moduleReference, value: FunctionCall({
name,
args: List.append(args, newArgs),
}) };
}
case "Value": {
const { body } = moduleReference.value;
return { ...moduleReference, value: FunctionCall({
name: body,
args: newArgs,
}) };
}
default: {
return moduleReference;
}
}
}
function flattenLeftPipe(leftPipe) {
const left = leftPipe.left;
const right = leftPipe.right;
switch (right.kind) {
case "FunctionCall": {
const { name, args } = right;
return FunctionCall({
name,
args: List.append(args, [left]),
});
}
case "Value": {
const { body } = right;
return FunctionCall({
name: body,
args: [left],
});
}
case "ModuleReference": {
return addArgsToModuleReference(right, [left]);
}
case "Lambda": {
return LambdaCall({
lambda: right,
args: [left],
});
}
case "LeftPipe": {
switch (right.left.kind) {
case "FunctionCall": {
const { args, name } = right.left;
const fn = FunctionCall({
name,
args: List.append(args, [left]),
});
return flattenLeftPipe({
kind: "LeftPipe",
left: fn,
right: right.right,
});
}
case "Value": {
const { body } = right.left;
const fn = FunctionCall({
name: body,
args: [left],
});
return flattenLeftPipe({
kind: "LeftPipe",
left: fn,
right: right.right,
});
}
case "ModuleReference": {
const fn = addArgsToModuleReference(right.left, [left]);
return flattenLeftPipe({
kind: "LeftPipe",
left: fn,
right: right.right,
});
}
case "Lambda": {
const fn = LambdaCall({
lambda: right.left,
args: [left],
});
return flattenLeftPipe({
kind: "LeftPipe",
left: fn,
right: right.right,
});
}
case "LeftPipe": {
return right;
}
default: {
return right.left;
}
}
;
}
}
}
function generateModule(module) {
if (module.namespace === "Relative") {
const withoutQuotes = module.name.slice(1, -1);
const name = (function () {
switch (module.alias.kind) {
case "Just": {
const { value } = module.alias;
return value;
}
case "Nothing": {
return (0, Utils_1.getNameFromPath)(withoutQuotes);
}
}
})();
const filteredExposing = (function () {
switch (module.alias.kind) {
case "Just": {
const { value } = module.alias;
return List.filter(function (expose) {
return expose !== value;
}, module.exposing);
}
case "Nothing": {
return module.exposing;
}
}
})();
const exposed = `import { ${filteredExposing.join(", ")} } from ${module.name};`;
if (module.exposing.length === 0) {
return `import * as ${name} from ${module.name};`;
}
else {
switch (module.alias.kind) {
case "Just": {
return `import * as ${name} from ${module.name};\n${exposed}`;
}
case "Nothing": {
return exposed;
}
}
;
}
}
else {
const name = (function () {
switch (module.alias.kind) {
case "Just": {
const { value } = module.alias;
return value;
}
case "Nothing": {
return module.name;
}
}
})();
const exposed = `import { ${module.exposing.join(", ")} } from "${module.name}";`;
if (module.exposing.length === 0) {
return `import * as ${name} from "${module.name}";`;
}
else {
switch (module.alias.kind) {
case "Just": {
return `import * as ${name} from "${module.name}";\n${exposed}`;
}
case "Nothing": {
return exposed;
}
}
;
}
;
}
}
function generateImportBlock(imports) {
return (function (y) {
return y.join("\n");
})(List.map(generateModule, List.filter(function (module) {
return module.name !== "globalThis";
}, imports.modules)));
}
function generateExportBlock(exports) {
return (function (x) {
return x.join("\n");
})(List.map(function (name) {
return `export { ${name} };`;
}, exports.names));
}