purus 0.8.1 → 0.9.0

package/lib/purus-core.js

@@ -12,6 +12,7 @@ const path = require("path");
 
 const COMPILER_JS = path.join(__dirname, "purus-compiler.js");
 const VERSION = require("../package.json").version;
+const stdlib = require("./stdlib.js");
 
 /**
  * Compile Purus source code to JavaScript.
@@ -25,7 +26,7 @@ function compile(source, options = {}) {
   const { header = true, strict = true, type: moduleType } = options;
   const tmpFile = path.join(
     require("os").tmpdir(),
-    `purus_${Date.now()}_${Math.random().toString(36).slice(2)}.purus`
+    `purus_${Date.now()}_${Math.random().toString(36).slice(2)}.purus`,
   );
   const fs = require("fs");
   try {
@@ -38,11 +39,12 @@ function compile(source, options = {}) {
       args.push("--type", "commonjs");
     }
     args.push(tmpFile);
-    const result = execFileSync(process.execPath, [COMPILER_JS, ...args], {
+    let result = execFileSync(process.execPath, [COMPILER_JS, ...args], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 30000,
     });
+    result = stdlib.postProcess(result);
     if (header) {
       return `// Generated by Purus ${VERSION}\n${result}`;
     }
@@ -66,7 +68,7 @@ function compile(source, options = {}) {
 function check(source) {
   const tmpFile = path.join(
     require("os").tmpdir(),
-    `purus_${Date.now()}_${Math.random().toString(36).slice(2)}.purus`
+    `purus_${Date.now()}_${Math.random().toString(36).slice(2)}.purus`,
   );
   const fs = require("fs");
   try {

package/lib/run-wrapper.js

@@ -17,7 +17,10 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === "--no-header") {
     noHeader = true;
   } else if (args[i] === "--strict") {
-    if (i + 1 < args.length && (args[i + 1] === "true" || args[i + 1] === "false")) {
+    if (
+      i + 1 < args.length &&
+      (args[i + 1] === "true" || args[i + 1] === "false")
+    ) {
       strict = args[++i] === "true";
     } else {
       strict = true;
@@ -60,7 +63,11 @@ if (entry && fs.existsSync(entry) && fs.statSync(entry).isFile()) {
   const source = fs.readFileSync(entry, "utf8");
   const useStrict = strict !== null ? strict : true;
   const resolvedModule = resolveModuleType(entry, moduleType);
-  const js = compile(source, { header: false, strict: useStrict, module: resolvedModule });
+  const js = compile(source, {
+    header: false,
+    strict: useStrict,
+    module: resolvedModule,
+  });
   const m = new (require("module"))();
   m._compile(js, entry);
 } else {
@@ -110,11 +117,15 @@ if (entry && fs.existsSync(entry) && fs.statSync(entry).isFile()) {
     const source = fs.readFileSync(f, "utf8");
     const useStrict2 = strict !== null ? strict : true;
     const resolvedModule = resolveModuleType(f, moduleType);
-    const js = compile(source, { header: false, strict: useStrict2, module: resolvedModule });
+    const js = compile(source, {
+      header: false,
+      strict: useStrict2,
+      module: resolvedModule,
+    });
 
     const tmpFile = path.join(
       require("os").tmpdir(),
-      `purus_run_${Date.now()}_${Math.random().toString(36).slice(2)}.js`
+      `purus_run_${Date.now()}_${Math.random().toString(36).slice(2)}.js`,
     );
     try {
       fs.writeFileSync(tmpFile, js, "utf8");

package/lib/stdlib.js

@@ -0,0 +1,152 @@
+/**
+ * Purus stdlib resolver — replaces codegen markers with actual JS from stdlib/*.js
+ *
+ * Marker emitted by the MoonBit compiler:
+ *   // @purus-stdlib:whole:<module>:<binding>
+ *
+ * Tree-shaking: only properties actually referenced as `binding.xxx`
+ * in the rest of the code are included in the emitted object.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const STDLIB_DIR = path.join(__dirname, "..", "stdlib");
+const cache = {};
+
+// Global objects reachable by spread name
+const GLOBALS = { Math, JSON };
+
+/** Load and cache a stdlib module. */
+function load(name) {
+  if (cache[name]) return cache[name];
+  const fp = path.join(STDLIB_DIR, name + ".js");
+  const src = fs.readFileSync(fp, "utf8");
+  const m = require(fp);
+  cache[name] = {
+    src,
+    mod: m.mod,
+    spread: m.spread || null,
+    spreadObj: m.spread ? GLOBALS[m.spread] || null : null,
+    constants: m.constants || {},
+  };
+  return cache[name];
+}
+
+/** Extract source of a single method from exports.mod block. */
+function extractMethod(src, name) {
+  // Match:  name( ... ) { ... }  (balanced braces)
+  const re = new RegExp(`(?:^|[,\\n])\\s*(${name}\\([^)]*\\)\\s*\\{)`, "m");
+  const hit = re.exec(src);
+  if (!hit) return null;
+  const start = src.indexOf(hit[1], hit.index);
+  let depth = 0,
+    end = start;
+  let inBrace = false;
+  for (let i = start; i < src.length; i++) {
+    if (src[i] === "{") {
+      depth++;
+      inBrace = true;
+    }
+    if (src[i] === "}") depth--;
+    if (inBrace && depth === 0) {
+      end = i;
+      break;
+    }
+  }
+  return src.slice(start, end + 1);
+}
+
+/** Collect `this.xxx(` calls in a method body to find internal deps. */
+function collectThisDeps(methodSrc) {
+  const deps = new Set();
+  for (const m of methodSrc.matchAll(/this\.(\w+)\s*\(/g)) deps.add(m[1]);
+  return deps;
+}
+
+/** Recursively collect all deps for a set of method names. */
+function collectAllDeps(mod, src, names) {
+  const all = new Set(names);
+  const queue = [...names];
+  while (queue.length) {
+    const name = queue.pop();
+    if (typeof mod[name] !== "function") continue;
+    const body = extractMethod(src, name);
+    if (!body) continue;
+    for (const dep of collectThisDeps(body)) {
+      if (!all.has(dep) && dep in mod) {
+        all.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return all;
+}
+
+/**
+ * Resolve a whole-module import with tree-shaking.
+ * Scans `restOfCode` for `binding.xxx` to determine used properties.
+ */
+function resolveWhole(moduleName, binding, restOfCode) {
+  const m = load(moduleName);
+
+  // Collect used property names
+  const re = new RegExp("\\b" + binding + "\\.(\\w+)\\b", "g");
+  const used = new Set();
+  for (const match of restOfCode.matchAll(re)) used.add(match[1]);
+
+  if (used.size === 0) return `const ${binding} = {};`;
+
+  // Expand with internal `this.xxx()` dependencies
+  const expanded = collectAllDeps(m.mod, m.src, used);
+
+  const props = [];
+
+  for (const name of expanded) {
+    // 1. constant alias (pi → Math.PI)
+    if (m.constants[name]) {
+      props.push(`${name}: ${m.spread}.${m.constants[name]}`);
+      continue;
+    }
+    // 2. spread member (abs → Math.abs)
+    if (m.spreadObj && name in m.spreadObj) {
+      props.push(`${name}: ${m.spread}.${name}`);
+      continue;
+    }
+    // 3. custom function — extract from source
+    if (typeof m.mod[name] === "function") {
+      const body = extractMethod(m.src, name);
+      if (body) {
+        props.push(body);
+        continue;
+      }
+    }
+  }
+
+  if (props.length === 0) return `const ${binding} = {};`;
+  if (props.length <= 3) return `const ${binding} = { ${props.join(", ")} };`;
+  return `const ${binding} = {\n  ${props.join(",\n  ")},\n};`;
+}
+
+/**
+ * Post-process compiler output: replace stdlib markers with actual JS.
+ */
+function postProcess(js) {
+  return js.replace(
+    /^(\s*)\/\/ @purus-stdlib:whole:([\w-]+):([\w-]+)$/gm,
+    (match, indent, moduleName, binding) => {
+      // Everything after this marker is "rest of code" for tree-shaking
+      const markerEnd = js.indexOf(match) + match.length;
+      const rest = js.slice(markerEnd);
+      const code = resolveWhole(moduleName, binding, rest);
+      return code
+        .split("\n")
+        .map((l) => indent + l)
+        .join("\n");
+    },
+  );
+}
+
+module.exports = { postProcess, load };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "purus",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Purus - /ˈpuː.rus/ means pure✨ in Latin - is a beautiful, simple, and easy-to-use language. It compiles to JavaScript. It makes your fingers free from the Shift key. With Purus, you can write code almost without pressing the Shift key.",
   "main": "index.js",
   "module": "index.mjs",
@@ -21,14 +21,22 @@
     "index.d.ts",
     "bin/",
     "lib/",
+    "stdlib/",
     "LICENSE",
     "README.md",
     "README-ja.md"
   ],
   "scripts": {
+    "test": "moon test --target js",
     "build:compiler": "moon build --target js",
     "build:copy": "node scripts/build.js",
     "build": "npm run build:compiler && npm run build:copy",
+    "lint": "moon check",
+    "lint:fix": "moon fmt",
+    "format": "moon fmt && prettier --write ./bin ./lib ./scripts ./stdlib ./index.d.ts ./index.js ./index.mjs",
+    "format:check": "moon fmt --check && prettier --check ./bin ./lib ./scripts ./stdlib ./index.d.ts ./index.js ./index.mjs",
+    "typecheck": "moon check",
+    "check": "npm run lint && npm run format:check && npm run build && npm run typecheck",
     "sync": "node scripts/sync-version.js",
     "prepublishOnly": "npm run sync && npm run build"
   },
@@ -58,5 +66,8 @@
   "homepage": "https://purus.work",
   "engines": {
     "node": ">=18"
+  },
+  "devDependencies": {
+    "prettier": "^3.8.1"
   }
 }

package/stdlib/p-array.js

@@ -0,0 +1,97 @@
+// Purus stdlib: p-array — Array utility functions
+//
+// test: node -e "const a = require('./stdlib/p-array'); console.log(a.mod.range(1,5))"
+
+exports.mod = {
+  isarray(val) {
+    return Array.isArray(val);
+  },
+  from(val) {
+    return Array.from(val);
+  },
+  of(...args) {
+    return Array.of(...args);
+  },
+  len(arr) {
+    return arr.length;
+  },
+  first(arr) {
+    return arr[0];
+  },
+  last(arr) {
+    return arr[arr.length - 1];
+  },
+  range(start, end, step) {
+    const s = step || 1;
+    const result = [];
+    for (let i = start; i < end; i += s) result.push(i);
+    return result;
+  },
+  flatten(arr, depth) {
+    return arr.flat(depth === undefined ? Infinity : depth);
+  },
+  unique(arr) {
+    return [...new Set(arr)];
+  },
+  zip(...arrs) {
+    const minLen = Math.min(...arrs.map((a) => a.length));
+    const result = [];
+    for (let i = 0; i < minLen; i++) {
+      result.push(arrs.map((a) => a[i]));
+    }
+    return result;
+  },
+  unzip(arr) {
+    if (arr.length === 0) return [];
+    const result = arr[0].map(() => []);
+    for (const tuple of arr) {
+      for (let i = 0; i < tuple.length; i++) {
+        result[i].push(tuple[i]);
+      }
+    }
+    return result;
+  },
+  chunk(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size) {
+      result.push(arr.slice(i, i + size));
+    }
+    return result;
+  },
+  sum(arr) {
+    return arr.reduce((a, b) => a + b, 0);
+  },
+  product(arr) {
+    return arr.reduce((a, b) => a * b, 1);
+  },
+  min(arr) {
+    return Math.min(...arr);
+  },
+  max(arr) {
+    return Math.max(...arr);
+  },
+  sortasc(arr) {
+    return [...arr].sort((a, b) => a - b);
+  },
+  sortdesc(arr) {
+    return [...arr].sort((a, b) => b - a);
+  },
+  compact(arr) {
+    return arr.filter(Boolean);
+  },
+  count(arr, fn) {
+    return arr.filter(fn).length;
+  },
+  groupby(arr, fn) {
+    const result = {};
+    for (const item of arr) {
+      const key = fn(item);
+      if (!result[key]) result[key] = [];
+      result[key].push(item);
+    }
+    return result;
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-datetime.js

@@ -0,0 +1,200 @@
+// Purus stdlib: datetime — date/time utility functions
+//
+// test: node -e "const d = require('./stdlib/datetime'); console.log(d.mod.now())"
+
+exports.mod = {
+  // --- current time ---
+  now() {
+    return Date.now();
+  },
+  today() {
+    const d = new Date();
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  },
+  timestamp() {
+    return Math.floor(Date.now() / 1000);
+  },
+
+  // --- create ---
+  create(year, month, day, hour, minute, second, ms) {
+    return new Date(
+      year,
+      (month || 1) - 1,
+      day || 1,
+      hour || 0,
+      minute || 0,
+      second || 0,
+      ms || 0,
+    ).getTime();
+  },
+  utccreate(year, month, day, hour, minute, second, ms) {
+    return Date.UTC(
+      year,
+      (month || 1) - 1,
+      day || 1,
+      hour || 0,
+      minute || 0,
+      second || 0,
+      ms || 0,
+    );
+  },
+  fromiso(str) {
+    return new Date(str).getTime();
+  },
+
+  // --- extract components (local) ---
+  year(t) {
+    return new Date(t).getFullYear();
+  },
+  month(t) {
+    return new Date(t).getMonth() + 1;
+  },
+  day(t) {
+    return new Date(t).getDate();
+  },
+  weekday(t) {
+    return new Date(t).getDay();
+  },
+  hour(t) {
+    return new Date(t).getHours();
+  },
+  minute(t) {
+    return new Date(t).getMinutes();
+  },
+  second(t) {
+    return new Date(t).getSeconds();
+  },
+  ms(t) {
+    return new Date(t).getMilliseconds();
+  },
+
+  // --- extract components (UTC) ---
+  utcyear(t) {
+    return new Date(t).getUTCFullYear();
+  },
+  utcmonth(t) {
+    return new Date(t).getUTCMonth() + 1;
+  },
+  utcday(t) {
+    return new Date(t).getUTCDate();
+  },
+  utcweekday(t) {
+    return new Date(t).getUTCDay();
+  },
+  utchour(t) {
+    return new Date(t).getUTCHours();
+  },
+  utcminute(t) {
+    return new Date(t).getUTCMinutes();
+  },
+  utcsecond(t) {
+    return new Date(t).getUTCSeconds();
+  },
+  utcms(t) {
+    return new Date(t).getUTCMilliseconds();
+  },
+
+  // --- extract components (timezone-aware) ---
+  _tzpart(t, tz, type) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+      fractionalSecondDigits: 3,
+      hour12: false,
+    }).formatToParts(new Date(t));
+    const p = parts.find((p) => p.type === type);
+    return p ? parseInt(p.value, 10) : 0;
+  },
+  tzyear(t, tz) {
+    return this._tzpart(t, tz, "year");
+  },
+  tzmonth(t, tz) {
+    return this._tzpart(t, tz, "month");
+  },
+  tzday(t, tz) {
+    return this._tzpart(t, tz, "day");
+  },
+  tzweekday(t, tz) {
+    const d = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      weekday: "short",
+    }).format(new Date(t));
+    return ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(d);
+  },
+  tzhour(t, tz) {
+    return this._tzpart(t, tz, "hour") % 24;
+  },
+  tzminute(t, tz) {
+    return this._tzpart(t, tz, "minute");
+  },
+  tzsecond(t, tz) {
+    return this._tzpart(t, tz, "second");
+  },
+
+  // --- format ---
+  toiso(t) {
+    return new Date(t).toISOString();
+  },
+  tolocale(t, locale, options) {
+    return new Date(t).toLocaleString(locale, options);
+  },
+  todate(t, locale, options) {
+    return new Date(t).toLocaleDateString(locale, options);
+  },
+  totime(t, locale, options) {
+    return new Date(t).toLocaleTimeString(locale, options);
+  },
+  format(t, tz, locale, options) {
+    return new Date(t).toLocaleString(locale || "en-US", {
+      timeZone: tz,
+      ...options,
+    });
+  },
+
+  // --- arithmetic ---
+  addms(t, n) {
+    return t + n;
+  },
+  addseconds(t, n) {
+    return t + n * 1000;
+  },
+  addminutes(t, n) {
+    return t + n * 60000;
+  },
+  addhours(t, n) {
+    return t + n * 3600000;
+  },
+  adddays(t, n) {
+    return t + n * 86400000;
+  },
+
+  // --- comparison ---
+  diff(a, b) {
+    return a - b;
+  },
+  diffdays(a, b) {
+    return (a - b) / 86400000;
+  },
+  diffhours(a, b) {
+    return (a - b) / 3600000;
+  },
+  diffminutes(a, b) {
+    return (a - b) / 60000;
+  },
+  diffseconds(a, b) {
+    return (a - b) / 1000;
+  },
+
+  // --- timezone info ---
+  offset(t) {
+    return new Date(t || Date.now()).getTimezoneOffset();
+  },
+  localtz() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  },
+};

package/stdlib/p-error.js

@@ -0,0 +1,45 @@
+// Purus stdlib: p-error — Error creation and inspection utilities
+//
+// test: node -e "const e = require('./stdlib/p-error'); console.log(e.mod.create('oops').message)"
+
+exports.mod = {
+  create(message) {
+    return new Error(message);
+  },
+  type(message) {
+    return new TypeError(message);
+  },
+  range(message) {
+    return new RangeError(message);
+  },
+  reference(message) {
+    return new ReferenceError(message);
+  },
+  syntax(message) {
+    return new SyntaxError(message);
+  },
+  uri(message) {
+    return new URIError(message);
+  },
+  iserror(val) {
+    return val instanceof Error;
+  },
+  message(err) {
+    return err instanceof Error ? err.message : String(err);
+  },
+  name(err) {
+    return err instanceof Error ? err.name : "Error";
+  },
+  stack(err) {
+    return err instanceof Error ? err.stack || "" : "";
+  },
+  cause(err) {
+    return err instanceof Error ? err.cause : undefined;
+  },
+  wrap(message, cause) {
+    return new Error(message, { cause });
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-json.js

@@ -0,0 +1,18 @@
+// Purus stdlib: json — JSON parse / stringify utilities
+//
+// test: node -e "const j = require('./stdlib/json'); console.log(j.mod.parse('{\"a\":1}'))"
+
+exports.mod = {
+  parse(str) {
+    return JSON.parse(str);
+  },
+  stringify(val) {
+    return JSON.stringify(val);
+  },
+  prettify(val, indent) {
+    return JSON.stringify(val, null, indent || 2);
+  },
+};
+
+exports.spread = "JSON";
+exports.constants = {};

package/stdlib/p-map.js

@@ -0,0 +1,57 @@
+// Purus stdlib: p-map — Map creation and operations
+//
+// test: node -e "const m = require('./stdlib/p-map'); const x = m.mod.from([['a',1]]); console.log(m.mod.get(x,'a'))"
+
+exports.mod = {
+  create(...pairs) {
+    return new Map(pairs);
+  },
+  from(iterable) {
+    return new Map(iterable);
+  },
+  fromobject(obj) {
+    return new Map(Object.entries(obj));
+  },
+  get(map, key) {
+    return map.get(key);
+  },
+  set(map, key, value) {
+    const m = new Map(map);
+    m.set(key, value);
+    return m;
+  },
+  delete(map, key) {
+    const m = new Map(map);
+    m.delete(key);
+    return m;
+  },
+  has(map, key) {
+    return map.has(key);
+  },
+  size(map) {
+    return map.size;
+  },
+  keys(map) {
+    return [...map.keys()];
+  },
+  values(map) {
+    return [...map.values()];
+  },
+  entries(map) {
+    return [...map.entries()];
+  },
+  clear(map) {
+    const m = new Map(map);
+    m.clear();
+    return m;
+  },
+  toobject(map) {
+    return Object.fromEntries(map);
+  },
+  merge(a, b) {
+    return new Map([...a, ...b]);
+  },
+};
+
+exports.spread = null;
+exports.constants = {};