@sealcode/sealgen 0.11.8 → 0.12.0

package/lib/src/generate-routes.js

@@ -0,0 +1,75 @@
+import { promises as fs } from "fs";
+import * as prettier from "prettier";
+import { relative } from "path";
+import _locreq from "locreq";
+import { walkDir } from "./utils/walk.js";
+import { importPath } from "./utils/import-path.js";
+import { assertType, predicates } from "@sealcode/ts-predicates";
+import { unescape_url_params } from "./utils/escape-url-params.js";
+import { getPrettierConfig } from "./utils/prettier.js";
+import { Templates } from "./templates/templates.js";
+const target_locreq = _locreq(process.cwd());
+async function extractActionName(full_file_path) {
+    const file_content = await fs.readFile(full_file_path, "utf-8");
+    const result = /export const actionName = "(\w+)"/.exec(file_content);
+    if (result === null) {
+        throw new Error("Missing 'export const actionName' statement?");
+    }
+    return assertType(result[1], predicates.string, "Missing export default class?");
+}
+function generateURL(actionName, url) {
+    const parts = url.split("/");
+    const params = parts
+        .filter((part) => part.startsWith(":"))
+        .map((part) => part.slice(1));
+    if (params.length === 0) {
+        return `export const ${actionName}URL = "${url}";`;
+    }
+    return `export const ${actionName}URL = (${params
+        .map((s) => s + ": string")
+        .join(", ")})=>\`${parts
+        .map((part) => part.startsWith(":") ? "${" + part.slice(1) + "}" : part)
+        .join("/")}\`;
+        ${actionName}URL.params = [${params
+        .map((param) => `"${param}"`)
+        .join(",")}];
+        ${actionName}URL.rawURL = "${url}";`;
+}
+export async function generateRoutes() {
+    const files = await Promise.all((await walkDir(target_locreq.resolve("src/back/routes")))
+        .filter((f) => Object.keys(Templates).some((key) => f.endsWith(`.${key}.ts`) || f.endsWith(`.${key}.tsx`)))
+        .map(async (fullpath) => ({
+        fullpath,
+        actionName: await extractActionName(fullpath),
+        url: unescape_url_params("/" +
+            relative(target_locreq.resolve("src/back/routes"), fullpath).replace(/\..+/, "") +
+            "/" // trailing slash is important here, as it enables to use the entire path while building relative URLs. For example, while visiting /users/123, the path ./add-photo leads to /users/add-photo. While visiting /users/123/ (note the trailing slash), the path ./add-photo leads to /users/123/add-photo
+        ),
+    })));
+    const routes_content = `// DO NOT EDIT! This file is generated automaticaly with npm run generate-routes
+
+import Router from "@koa/router";
+import { mount } from "@sealcode/sealgen";
+import * as URLs from "./urls.js"
+
+${files
+        .map(({ actionName, fullpath }) => `import { default as ${actionName} } from "${importPath(target_locreq.resolve("src/back/routes/routes.ts"), fullpath)}";`)
+        .join("\n")}
+
+export default function mountAutoRoutes(router: Router) {
+${files
+        .map(({ actionName }) => `	mount(router, URLs.${actionName}URL, ${actionName});`)
+        .join("\n")}
+}`;
+    const urls_content = `${files
+        .sort(({ url: url1 }, { url: url2 }) => (url1 < url2 ? -1 : 1))
+        .map(({ actionName, url }) => generateURL(actionName, url))
+        .join("\n")}
+`;
+    const prettier_config = await getPrettierConfig();
+    await fs.writeFile(target_locreq.resolve("src/back/routes/routes.ts"), prettier.format(routes_content, prettier_config));
+    await fs.writeFile(target_locreq.resolve("src/back/routes/urls.ts"), prettier.format(urls_content, prettier_config));
+    // eslint-disable-next-line no-console
+    console.log("Successfuly generated new src/back/routes/routes.ts and src/back/routes/urls.ts");
+}
+//# sourceMappingURL=generate-routes.js.map

package/lib/src/hehe.test.js

@@ -0,0 +1,7 @@
+import { hehe } from "./sample-lib.js";
+describe("hehe", () => {
+    it("hehe", () => {
+        hehe.hehe;
+    });
+});
+//# sourceMappingURL=hehe.test.js.map

package/lib/src/index.js

@@ -0,0 +1,19 @@
+export * as Controls from "./forms/controls/controls.js";
+export * as Field from "./forms/fields/field.js";
+export * as Fields from "./forms/fields/fields.js";
+export * from "./page/mountable.js";
+export * from "./page/page.js";
+export * from "./page/stateful-page.js";
+export * from "./forms/form-types.js";
+export * from "./forms/form.js";
+export * from "./page/props-parser.js";
+export * from "./utils/utils.js";
+export * from "./page/list.js";
+export * from "./page/sealious-list.js";
+export * from "./utils/translate.js";
+export * as sanitize from "./sanitize.js";
+export * from "./forms/multiform.js";
+export * as Components from "./components/components.js";
+export * from "./mount.js";
+export * from "./page/default-list-filters.js";
+//# sourceMappingURL=index.js.map

package/lib/src/make-env.js

@@ -0,0 +1,14 @@
+import os from "os";
+import { promises as fs } from "fs";
+import _locreq from "locreq";
+const target_locreq = _locreq(process.cwd());
+export async function makeEnv() {
+    const { uid, gid } = os.userInfo();
+    const content = `USER_ID=${uid}
+GROUP_ID=${gid}
+`;
+    const path = target_locreq.resolve(".env");
+    await fs.writeFile(path, content);
+    console.log("wrote .env");
+}
+//# sourceMappingURL=make-env.js.map

package/lib/src/make-hidden-inputs.js

@@ -0,0 +1,14 @@
+import { tempstream } from "tempstream";
+import { attribute } from "./sanitize.js";
+export function makeHiddenInputs(ctx, fields, values, fields_to_skip) {
+    return tempstream `${Object.entries(fields)
+        .filter(([key]) => !fields_to_skip.includes(key))
+        .map(([key, field]) => tempstream /* HTML */ `<input
+				type="hidden"
+				name="${key}"
+				value="${field
+        .getValue(ctx, values)
+        .then((r) => attribute(JSON.stringify(r.raw) || ""))}"
+			/>`)}`;
+}
+//# sourceMappingURL=make-hidden-inputs.js.map

package/lib/src/mount.js

@@ -0,0 +1,70 @@
+import { Middlewares } from "sealious";
+async function handleHtmlPromise(ctx, next) {
+    await next();
+    if (ctx.body instanceof Promise) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ctx.body = await ctx.body;
+    }
+    ctx.set("content-type", "text/html;charset=utf-8");
+}
+export function mount(router, url, mountable, use_dummy_app = false) {
+    const raw_url = typeof url === "string" ? url : url.rawURL;
+    const args = use_dummy_app
+        ? [
+            async (ctx, next) => {
+                // this dummy is a temporary solution it's ilustrating the ways that
+                // sealgen is coupled with sealious. Definitely room for improvement in this
+                // regard
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                ctx.$app = {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    Logger: new Proxy({}, {
+                        get: (_target, prop) => {
+                            if (prop === "info") {
+                                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                                return () => { };
+                            }
+                            else {
+                                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                                return () => { };
+                            }
+                        },
+                    }),
+                    getString: (x) => x,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                await next();
+            },
+            Middlewares.parseBody(),
+            handleHtmlPromise,
+        ]
+        : [
+            Middlewares.extractContext(),
+            Middlewares.parseBody(),
+            handleHtmlPromise,
+        ];
+    router.use(raw_url, ...args);
+    mountable.init();
+    // to automatically add trailing slashes:
+    router.get(raw_url.slice(0, -1), async (ctx, next) => {
+        const url2 = ctx.URL;
+        if (!url2.pathname.endsWith("/")) {
+            url2.pathname += "/";
+            ctx.redirect(url2.href);
+        }
+        await next();
+    });
+    router.use(raw_url, async (ctx, next) => {
+        ctx.set("content-type", "text/html;charset=utf-8");
+        const access_result = await mountable.canAccess(ctx);
+        if (!access_result.canAccess) {
+            ctx.status = 403;
+            ctx.body = access_result.message || "no access";
+            return;
+        }
+        await next();
+    });
+    mountable.mount(router, raw_url);
+}
+//# sourceMappingURL=mount.js.map

package/lib/src/notifier.js

@@ -0,0 +1,19 @@
+import WebSocket from "ws";
+export function make_notifier(port) {
+    const server = new WebSocket.Server({
+        port,
+    });
+    let sockets = [];
+    server.on("connection", function (socket) {
+        sockets.push(socket);
+        // When a socket closes, or disconnects, remove it from the array.
+        socket.on("close", function () {
+            sockets = sockets.filter((s) => s !== socket);
+        });
+    });
+    console.log("build notifier listening on websocket at port " + port);
+    return function notify(message) {
+        sockets.forEach((s) => s.send(message));
+    };
+}
+//# sourceMappingURL=notifier.js.map

package/lib/src/page/access-control.js

@@ -0,0 +1,16 @@
+export function peopleWhoCan(action, collection) {
+    return async function (ctx) {
+        const policy = collection.getPolicy(action);
+        const result = await policy.check(ctx.$context);
+        if (!result) {
+            ctx.status = 403;
+            return { canAccess: false, message: "Not allowed" };
+        }
+        if (!result.allowed) {
+            ctx.status = 403;
+            return { canAccess: false, message: result.reason };
+        }
+        return { canAccess: true, message: "" };
+    };
+}
+//# sourceMappingURL=access-control.js.map

package/lib/src/page/default-list-filters.js

@@ -0,0 +1,40 @@
+export const BooleanListFilter = (value, field) => {
+    return /* HTML */ `<label>
+		${field.name}
+		<select name="filter[${field.name}]" autocomplete="off">
+			<option value="true" ${value == "true" ? "selected" : ""}>
+				True
+			</option>
+			<option value="false" ${value == "false" ? "selected" : ""}>
+				False
+			</option>
+			<option
+				value=""
+				${value == "null" ||
+        value == "" ||
+        value == "undefined" ||
+        value == undefined
+        ? "selected"
+        : ""}
+			>
+				-
+			</option>
+		</select>
+	</label>`;
+};
+export const SimpleTextFilter = (value, field) => {
+    return /* HTML */ `<label>
+		${field.name}
+		<input
+			type="text"
+			name="${field.name}"
+			${value ? `value="${value}"` : value}
+		/>
+	</label>`;
+};
+export const DefaultListFilters = {
+    boolean: BooleanListFilter,
+    text: SimpleTextFilter,
+    fallback: SimpleTextFilter,
+};
+//# sourceMappingURL=default-list-filters.js.map

package/lib/src/page/list.js

@@ -0,0 +1,184 @@
+import { tempstream } from "tempstream";
+import { Page } from "./page.js";
+import { naturalNumbers, UrlWithNewParams } from "../utils/utils.js";
+import { makeHiddenInputs } from "../make-hidden-inputs.js";
+import qs from "qs";
+import { NumberField } from "../forms/fields/number.js";
+import { SimpleFormField } from "../forms/fields/simple-form-field.js";
+export const BasePagePropsShape = {};
+export const BaseListPageFields = {
+    page: new NumberField(false, 1),
+    itemsPerPage: new NumberField(false, 12),
+    sort: new SimpleFormField(false),
+};
+const SORT_SEPARATOR = ":";
+function decodeSort(s) {
+    if (typeof s !== "string" || !s.includes(SORT_SEPARATOR)) {
+        return null;
+    }
+    let order = s.split(SORT_SEPARATOR)[1];
+    const field = s.split(SORT_SEPARATOR)[0];
+    if (order !== "asc" && order !== "desc") {
+        order = "asc";
+        return {
+            field,
+            order: order,
+        };
+    }
+    else {
+        return { field, order };
+    }
+}
+function encodeSort(field, order) {
+    return [field, order].join(SORT_SEPARATOR);
+}
+export class ListPage extends Page {
+    constructor() {
+        super(...arguments);
+        this.filterFields = {};
+        this.filterControls = [];
+    }
+    init() {
+        super.init();
+        for (const [fieldname, field] of Object.entries(this.filterFields)) {
+            field.init(fieldname);
+        }
+    }
+    renderListContainer(_, content) {
+        return tempstream `<div>${content}</div>`;
+    }
+    async getPaginationConfig(ctx) {
+        const values = await this.extractRawValues(ctx);
+        const { parsed: page } = await this.fields.page.getValue(ctx, values);
+        const { parsed: itemsPerPage } = await this.fields.itemsPerPage.getValue(ctx, values);
+        return { page, itemsPerPage };
+    }
+    async renderItems(ctx, values, items) {
+        if (!values) {
+            values = await this.extractRawValues(ctx);
+        }
+        const { itemsPerPage, page } = await this.getPaginationConfig(ctx);
+        const items_promise = this.getItems(ctx, page, itemsPerPage, values);
+        return tempstream `${(items
+            ? Promise.resolve(items)
+            : items_promise).then((items) => items.map((item, index) => this.renderItem(ctx, item, index)))}`;
+    }
+    async render(ctx) {
+        const values = await this.extractRawValues(ctx);
+        return tempstream `${this.renderPagination(ctx, values)}
+			  ${this.renderFilters(ctx)}
+${this.renderListContainer(ctx, this.renderItems(ctx, values))}`;
+    }
+    async renderPagination(ctx, values) {
+        const { itemsPerPage, page } = await this.getPaginationConfig(ctx);
+        const totalIems = await this.getTotalPages(ctx, itemsPerPage, values);
+        return tempstream /* HTML */ `<div class="list-pagination">
+			<div class="list-pagination__left">
+				${page > 1
+            ? this.renderPageButton(ctx, 1, "Pierwsza strona")
+            : ""}
+				${page > 1
+            ? this.renderPageButton(ctx, page - 1, "Poprzednia strona")
+            : ""}
+			</div>
+			<div class="list-pagination__center">
+				<select
+					title="choose page"
+					onchange="if (this.value) Turbo.visit(this.value)"
+				>
+					${Array.from(naturalNumbers(1, totalIems)).map((n) => /* HTML */ `<option
+							value="${UrlWithNewParams(ctx, 
+        //eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        this.propsParser.overwriteProp(ctx, {
+            page: n,
+        }))}"
+							${page === n ? "selected" : ""}
+						>
+							${n}
+						</option>`)}
+				</select>
+			</div>
+			<div class="list-pagination__right">
+				${page < totalIems
+            ? this.renderPageButton(ctx, page + 1, "Następna strona")
+            : ""}
+				${page < totalIems
+            ? this.renderPageButton(ctx, totalIems, "Ostatnia strona")
+            : ""}
+			</div>
+		</div>`;
+    }
+    renderPageButton(ctx, page, text) {
+        return /* HTML */ `<a
+			href="${UrlWithNewParams(ctx, 
+        //eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        this.propsParser.overwriteProp(ctx, {
+            page,
+        }))}"
+			>${text}</a
+		>`;
+    }
+    async getFilterValues(ctx) {
+        const filter = {};
+        const raw_values = await this.extractRawValues(ctx);
+        for (const [fieldname, field] of Object.entries(this.filterFields)) {
+            // eslint-disable-next-line no-await-in-loop
+            const { parsed } = await field.getValue(ctx, raw_values);
+            filter[fieldname] = field.mapToFilter(parsed);
+        }
+        return filter;
+    }
+    async getSort(ctx) {
+        const { sort } = await this.extractRawValues(ctx);
+        const decoded = decodeSort(sort);
+        if (decoded === null) {
+            return this.getDefaultSort(ctx);
+        }
+        else {
+            return decoded;
+        }
+    }
+    makeSortLink(ctx, field, order) {
+        const url = new URL(ctx.url, "https://example.com");
+        const params = qs.parse(url.search.slice(1));
+        params.sort = encodeSort(field, order);
+        url.search = qs.stringify(params);
+        return url.pathname + url.search;
+    }
+    async renderFilters(ctx) {
+        const values = await this.extractRawValues(ctx);
+        return tempstream /* HTML */ `<form method="GET">
+			${makeHiddenInputs(ctx, this.fields, values, [
+            "page",
+            ...Object.values(this.filterFields).map((f) => f.name),
+        ])}
+			${this.filterControls.map((control) => {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return control.render(this.makeFormControlContext(ctx, { raw_values: values, messages: [] }, false));
+        })}
+		</form>`;
+    }
+    async renderHeading(ctx, field, label = field) {
+        const current_sort = await this.getSort(ctx);
+        const current_order = current_sort?.field == field ? current_sort.order : null;
+        const order = current_order == "desc" ? "asc" : "desc";
+        return /* HTML */ `<th>
+			<a href="${this.makeSortLink(ctx, field, order)}"
+				>${label}
+				${(current_order && (current_order == "asc" ? "↑" : "↓")) ||
+            ""}</a
+			>
+		</th>`;
+    }
+    getDefaultSort(_) {
+        return null;
+    }
+    renderTableHead(ctx, fields) {
+        return tempstream /* HTML */ `<thead>
+			<tr>
+				${fields.map(({ label, field }) => this.renderHeading(ctx, field, label))}
+			</tr>
+		</thead>`;
+    }
+}
+//# sourceMappingURL=list.js.map

package/lib/src/page/mountable-with-fields.js

@@ -0,0 +1,85 @@
+import { tempstream } from "tempstream";
+import { FormControlContext, } from "../forms/controls/form-control.js";
+import { Mountable } from "./mountable.js";
+export class MountableWithFields extends Mountable {
+    constructor() {
+        super();
+        this.field_names_prefix = ""; // useful for multiform, where many forms are merged into one and field assignment is made using the prefix
+        this.form_id = ""; // all fields within this mountable will be tied to form of this id
+        if (!this.fields)
+            this.fields = {};
+    }
+    init() {
+        for (const [name, field] of Object.entries(this.fields)) {
+            field.init(name);
+        }
+    }
+    makeFormControlContext(ctx, data, validate, field_name_prefix = this.field_names_prefix, form_id = this.form_id) {
+        return new FormControlContext(ctx, data.raw_values, data.messages, field_name_prefix, form_id, validate);
+    }
+    // this one is meant to be overwritten
+    async validateValues(ctx, data) {
+        return {
+            valid: true,
+            error: "",
+        };
+    }
+    async validate(ctx, values) {
+        const field_errors = {};
+        let valid = true;
+        const form_messages = [];
+        await Promise.all(Object.entries(values)
+            .filter(([fieldname]) => fieldname in this.fields)
+            .map(async ([key]) => {
+            const field = this.fields[key];
+            const { valid: fieldvalid, message: fieldmessage } = await field.getValue(ctx, values);
+            if (!fieldvalid) {
+                valid = false;
+                field_errors[field.name] = fieldmessage;
+            }
+        }));
+        const formValidationResult = await this.validateValues(ctx, values);
+        if (!formValidationResult.valid) {
+            form_messages.push({
+                type: "error",
+                text: formValidationResult.error,
+            });
+            valid = false;
+        }
+        return { valid, field_errors, form_messages };
+    }
+    renderControls(fctx) {
+        return tempstream /* HTML */ `${this.controls.map((control) => control.render(fctx))}`;
+    }
+    async renderError(_, error) {
+        return error.message;
+    }
+    renderMessages(_, data) {
+        return tempstream /* HTML */ `<div class="form-messages">
+			${data.messages.map((message) => `<div class="form-message form-message--${message.type}">${message.text}</div>`)}
+		</div>`;
+    }
+    async getParsedValues(ctx) {
+        const raw_values = await this.extractRawValues(ctx);
+        const result = {};
+        const promises = Object.entries(this.fields).map(async ([key, field]) => {
+            const { parsed } = await field.getValue(ctx, raw_values);
+            result[key] = parsed;
+        });
+        await Promise.all(promises);
+        return result;
+    }
+    async getDatabaseValues(ctx) {
+        const raw_values = await this.extractRawValues(ctx);
+        const result = {};
+        const promises = Object.entries(this.fields).map(async ([key, field]) => {
+            const db_value = await field.getDatabaseValue(ctx, raw_values);
+            if (db_value !== undefined) {
+                result[key] = db_value;
+            }
+        });
+        await Promise.all(promises);
+        return result;
+    }
+}
+//# sourceMappingURL=mountable-with-fields.js.map

package/lib/src/page/mountable.js

@@ -0,0 +1,5 @@
+export class Mountable {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    init() { }
+}
+//# sourceMappingURL=mountable.js.map

package/lib/src/page/page.js

@@ -0,0 +1,26 @@
+import { tempstream } from "tempstream";
+import { MountableWithFields, } from "./mountable-with-fields.js";
+import { AllQueryParams } from "./props-parser.js";
+export class Page extends MountableWithFields {
+    constructor() {
+        super(...arguments);
+        this.propsParser = new AllQueryParams();
+        this.controls = [];
+    }
+    mount(router, path) {
+        router.get(path, async (ctx) => {
+            ctx.body = await this.render(ctx);
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async canAccess(_) {
+        return { canAccess: true, message: "" };
+    }
+    async renderError(_, error) {
+        return tempstream /* HTML */ `<div>${error.message}</div>`;
+    }
+    async extractRawValues(ctx) {
+        return this.propsParser.decode(ctx) || {};
+    }
+}
+//# sourceMappingURL=page.js.map

package/lib/src/page/props-parser.js

@@ -0,0 +1,23 @@
+import merge from "merge";
+// page props parser is only tasked with getting the raw props from *somewhere*
+// and being able to put new values back to that somewhere. Parsing to numbers
+// or any other exotic types is done by fields logic.
+export class PagePropsParser {
+    overwriteProp(ctx, new_props) {
+        const result = {};
+        merge.recursive(result, this.decode(ctx), new_props);
+        return result;
+    }
+}
+export class AllQueryParams extends PagePropsParser {
+    decode(ctx) {
+        return ctx.query;
+    }
+    encode(props) {
+        return props;
+    }
+    getHTMLInputName(prop_name) {
+        return prop_name;
+    }
+}
+//# sourceMappingURL=props-parser.js.map

package/lib/src/page/sealious-list.js

@@ -0,0 +1,59 @@
+import { ListPage } from "./list.js";
+import { peopleWhoCan } from "./access-control.js";
+import qs from "qs";
+import { is, predicates } from "@sealcode/ts-predicates";
+export class SealiousItemListPage extends ListPage {
+    constructor(collection) {
+        super();
+        this.collection = collection;
+        this.canAccess = peopleWhoCan("list", this.collection);
+    }
+    async getContextForList(ctx) {
+        return ctx.$context;
+    }
+    async getTotalPages(ctx, itemsPerPage) {
+        const query = this.collection.list(await this.getContextForList(ctx));
+        await this.addFilter(ctx, query);
+        const { items } = await query.fetch();
+        return Math.ceil(items.length / itemsPerPage);
+    }
+    async addFilter(ctx, list) {
+        const filters = await this.getFilterValues(ctx);
+        for (const key in filters) {
+            if (filters[key] === undefined || filters[key] == "") {
+                delete filters[key];
+            }
+        }
+        if (Object.keys(filters).length) {
+            list.filter(filters);
+        }
+    }
+    async makeQuery(ctx) {
+        const query = this.collection.list(await this.getContextForList(ctx));
+        const sort = await this.getSort(ctx);
+        if (sort) {
+            query.sort({ [sort.field]: sort.order });
+        }
+        return query;
+    }
+    async getItems(ctx, page, itemsPerPage) {
+        const query = await this.makeQuery(ctx);
+        await this.addFilter(ctx, query);
+        const { items } = await query
+            .paginate({ items: itemsPerPage, page })
+            .fetch();
+        return items;
+    }
+    async getFilterValues(ctx) {
+        const query_params = qs.parse(ctx.search.slice(1));
+        const _filter_values = query_params?.filter || {};
+        let filter_values = is(_filter_values, predicates.record(predicates.string, predicates.string))
+            ? _filter_values
+            : {};
+        return filter_values;
+    }
+    async renderItem(_, item, index) {
+        return `<div>${item.id}</div>`;
+    }
+}
+//# sourceMappingURL=sealious-list.js.map