@weborigami/language 0.6.4 → 0.6.6

package/src/compiler/parserHelpers.js

@@ -16,8 +16,13 @@ const YAML = YAMLModule.default ?? YAMLModule.YAML;
 
 // Markers in compiled output, will get optimized away
 export const markers = {
-  global: Symbol("global"), // Global reference
   external: Symbol("external"), // External reference
+  global: Symbol("global"), // Global reference
+  paramArray: Symbol("paramArray"), // Parameter array destructuring
+  paramInitializer: Symbol("paramInitializer"), // Parameter default value
+  paramName: Symbol("paramName"), // Parameter name
+  paramObject: Symbol("paramObject"), // Parameter object destructuring
+  paramRest: Symbol("paramRest"), // Rest operator in parameters
   property: Symbol("property"), // Property access
   reference: Symbol("reference"), // Reference to local, scope, or global
   spread: Symbol("spread"), // Spread operator
@@ -69,6 +74,21 @@ export function applyMacro(code, name, macro) {
   return annotate(applied, code.location);
 }
 
+function checkDuplicateParamNames(flat) {
+  const names = new Set();
+  for (const binding of flat) {
+    const paramName = binding[0];
+    if (names.has(paramName)) {
+      const error = new SyntaxError(`Duplicate parameter name "${paramName}"`);
+      /** @type {any} */ (error).location = /** @type {any} */ (
+        binding
+      ).location;
+      throw error;
+    }
+    names.add(paramName);
+  }
+}
+
 /**
  * Create an array
  *
@@ -236,10 +256,8 @@ export function makeDeferredArguments(args) {
     if (arg instanceof Array && arg[0] === ops.literal) {
       return arg;
     }
-    const lambdaParameters = annotate([], arg.location);
-    /** @type {AnnotatedCodeItem} */
-    const fn = [ops.lambda, lambdaParameters, arg];
-    return annotate(fn, arg.location);
+    const params = annotate([], arg.location);
+    return makeLambda(params, arg, arg.location);
   });
 }
 
@@ -257,6 +275,40 @@ export function makeDocument(front, body, location) {
   return annotate([ops.object, ...entries], location);
 }
 
+/**
+ * Create a lambda function with the given parameters.
+ *
+ * @param {AnnotatedCode} params
+ * @param {AnnotatedCode} body
+ * @param {CodeLocation} location
+ */
+export function makeLambda(params, body, location) {
+  // Create a reference that at runtime resolves to parameters array. All
+  // parameter references will use this as their basis.
+  const reference = annotate([ops.params, 0], location);
+
+  // Shared state for parameter processing
+  const state = { tempVariableCount: 0 };
+
+  const bindings = makeParamArray(params, reference, state);
+  const annotatedBindings = annotate(bindings, params.location);
+
+  // Calculate function "length" (number of expected arguments). The length
+  // can't be easily calculated at runtime because default values and rest
+  // parameters affect it.
+  let length = 0;
+  for (const param of params) {
+    const [op] = param;
+    if (op === markers.paramInitializer || op === markers.paramRest) {
+      // Default value or rest parameter: stop counting
+      break;
+    }
+    length++;
+  }
+
+  return annotate([ops.lambda, length, annotatedBindings, body], location);
+}
+
 /**
  * From the given spreads within an object spread, return the merge.
  *
@@ -413,19 +465,129 @@ function makeOptionalCall(target, chain, location) {
     location
   );
 
-  // Create the call to be made if the target is not null/undefined
-  const call = makeCallChain(optionalTraverse, chain, location);
+  // Create the call body to be made if the target is not null/undefined
+  const body = makeCallChain(optionalTraverse, chain, location);
 
   // Create a function that takes __optional__ and makes the call
-  const optionalLiteral = annotate([ops.literal, optionalKey], location);
-  const lambdaParameters = annotate([optionalLiteral], location);
-  const lambda = annotate([ops.lambda, lambdaParameters, call], location);
+  const optionalParam = annotate([markers.paramName, optionalKey], location);
+  const params = annotate([optionalParam], location);
+  const lambda = makeLambda(params, body, location);
 
   // Create the call to ops.optional
   const optionalCall = annotate([ops.optional, target, lambda], location);
   return optionalCall;
 }
 
+// Return bindings for the given parameter
+function makeParam(parameter, reference, state) {
+  const [marker, ...args] = parameter;
+  switch (marker) {
+    case markers.paramArray:
+      return makeParamArray(args, reference, state);
+
+    case markers.paramInitializer:
+      return makeParamInitializer(parameter, reference, state);
+
+    case markers.paramName:
+      return makeParamName(parameter, reference, state);
+
+    case markers.paramObject:
+      return makeParamObject(args, reference, state);
+
+    default:
+      throw new Error(`Unknown parameter type: ${parameter[0]}`);
+  }
+}
+
+// Return bindings for the array destructuring parameter
+function makeParamArray(entries, reference, state) {
+  const bindings = entries.map((entry, index) => {
+    if (entry === undefined) {
+      return []; // Skip missing entry
+    } else if (entry[0] === markers.paramRest) {
+      // Rest parameter
+      const sliceFunction = annotate([reference, "slice"], entry.location);
+      const sliceCall = annotate([sliceFunction, index], entry.location);
+      return makeParam(entry[1], sliceCall, state);
+    }
+    // Other type of parameter
+    const indexReference = annotate([reference, index], entry.location);
+    return makeParam(entry, indexReference, state);
+  });
+
+  const flat = bindings.flat();
+  checkDuplicateParamNames(flat);
+  return flat;
+}
+
+// Return binding for a parameter with a default value
+function makeParamInitializer(parameter, reference, state) {
+  const [baseParam, defaultValue] = parameter.slice(1);
+
+  if (defaultValue[0] === ops.literal) {
+    // Literal default value can be inlined
+    const defaultReference = annotate(
+      [ops.defaultValue, reference, defaultValue],
+      parameter.location
+    );
+    return makeParam(baseParam, defaultReference, state);
+  }
+
+  // Need to introduce a temporary variable so that the default value, if it's
+  // an expression, is only evaluated once.
+  const deferred = makeDeferredArguments([defaultValue])[0];
+  const defaultReference = annotate(
+    [ops.defaultValue, reference, deferred],
+    parameter.location
+  );
+  const tempVariableName = `__temp${state.tempVariableCount++}__`;
+  const tempBinding = annotate(
+    [tempVariableName, defaultReference],
+    parameter.location
+  );
+
+  const selfReference = annotate([ops.inherited, 0], parameter.location);
+  const tempReference = annotate(
+    [selfReference, tempVariableName],
+    parameter.location
+  );
+
+  const paramBindings = makeParam(baseParam, tempReference, state);
+  return [tempBinding, ...paramBindings];
+}
+
+// Return binding for a single parameter name
+function makeParamName(parameter, reference, state) {
+  const paramName = parameter[1];
+  // Return as an array with one entry
+  const bindings = [annotate([paramName, reference], parameter.location)];
+  return bindings;
+}
+
+// Return bindings for an object destructuring parameter
+function makeParamObject(entries, reference, state) {
+  const keys = [];
+  const bindings = entries.map((entry) => {
+    if (entry[0] === markers.paramRest) {
+      // Rest parameter; exclude keys we've seen so far
+      const annotatedKeys = annotate([ops.array, ...keys], entry.location);
+      const objectRest = annotate(
+        [ops.objectRest, reference, annotatedKeys],
+        entry.location
+      );
+      return makeParam(entry[1], objectRest, state);
+    }
+    const [key, binding] = entry;
+    keys.push(key);
+    const propertyValue = annotate([reference, key], entry.location);
+    return makeParam(binding, propertyValue, state);
+  });
+
+  const flat = bindings.flat();
+  checkDuplicateParamNames(flat);
+  return flat;
+}
+
 /**
  * Handle a path with one or more segments separated by slashes.
  *

package/src/project/projectConfig.js

@@ -1,12 +1,12 @@
 import { FileMap, toString } from "@weborigami/async-tree";
 import ori_handler from "../handlers/ori_handler.js";
 import coreGlobals from "./coreGlobals.js";
-import projectRoot from "./projectRoot.js";
+import projectRootFromPath from "./projectRootFromPath.js";
 
 const mapPathToConfig = new Map();
 
 export default async function config(dir = process.cwd()) {
-  const root = await projectRoot(dir);
+  const root = await projectRootFromPath(dir);
 
   const rootPath = root.path;
   const cached = mapPathToConfig.get(rootPath);

package/src/project/projectGlobals.js

@@ -4,14 +4,14 @@ import projectConfig from "./projectConfig.js";
 let globals;
 
 // Core globals plus project config
-export default async function projectGlobals() {
+export default async function projectGlobals(dir = process.cwd()) {
   if (!globals) {
     // Start with core globals
     globals = await coreGlobals();
     // Now get config. The config.ori file may require access to globals,
     // which will obtain the core globals set above. Once we've got the
     // config, we add it to the globals.
-    const config = await projectConfig();
+    const config = await projectConfig(dir);
     Object.assign(globals, config);
   }
 

package/src/project/projectRoot.js

@@ -1,58 +1,9 @@
-import { FileMap } from "@weborigami/async-tree";
-import path from "node:path";
-import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
-
-const configFileName = "config.ori";
-const packageFileName = "package.json";
-
-const mapPathToRoot = new Map();
+import { Tree } from "@weborigami/async-tree";
 
 /**
- * Return an OrigamiFileMap object for the current project.
- *
- * This searches the current directory and its ancestors for an Origami file
- * called `config.ori`. If an Origami configuration file is found, the
- * containing folder is considered to be the project root.
- *
- * Otherwise, this looks for a package.json file to determine the project root.
- * If no package.json is found, the current folder is used as the project root.
- *
- *
- * @param {string} [dirname]
+ * Return an OrigamiFileMap object for the current code context.
  */
-export default async function projectRoot(dirname = process.cwd()) {
-  const cached = mapPathToRoot.get(dirname);
-  if (cached) {
-    return cached;
-  }
-
-  let root;
-  let value;
-  // Use a plain FileMap to avoid loading extension handlers
-  const currentTree = new FileMap(dirname);
-  // Try looking for config file
-  value = await currentTree.get(configFileName);
-  if (value) {
-    // Found config file
-    root = new OrigamiFileMap(currentTree.path);
-  } else {
-    // Try looking for package.json
-    value = await currentTree.get(packageFileName);
-    if (value) {
-      // Found package.json
-      root = new OrigamiFileMap(currentTree.path);
-    } else {
-      // Move up a folder and try again
-      const parentPath = path.dirname(dirname);
-      if (parentPath !== dirname) {
-        root = await projectRoot(parentPath);
-      } else {
-        // At filesystem root, use current working directory
-        root = new OrigamiFileMap(process.cwd());
-      }
-    }
-  }
-
-  mapPathToRoot.set(dirname, root);
-  return root;
+export default async function projectRoot(state) {
+  return Tree.root(state.container);
 }
+projectRoot.needsState = true;

package/src/project/projectRootFromPath.js

@@ -0,0 +1,58 @@
+import { FileMap } from "@weborigami/async-tree";
+import path from "node:path";
+import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
+
+const configFileName = "config.ori";
+const packageFileName = "package.json";
+
+const mapPathToRoot = new Map();
+
+/**
+ * Return an OrigamiFileMap object for the current project root.
+ *
+ * This searches the current directory and its ancestors for an Origami file
+ * called `config.ori`. If an Origami configuration file is found, the
+ * containing folder is considered to be the project root.
+ *
+ * Otherwise, this looks for a package.json file to determine the project root.
+ * If no package.json is found, the current folder is used as the project root.
+ *
+ *
+ * @param {string} [dirname]
+ */
+export default async function projectRootFromPath(dirname = process.cwd()) {
+  const cached = mapPathToRoot.get(dirname);
+  if (cached) {
+    return cached;
+  }
+
+  let root;
+  let value;
+  // Use a plain FileMap to avoid loading extension handlers
+  const currentTree = new FileMap(dirname);
+  // Try looking for config file
+  value = await currentTree.get(configFileName);
+  if (value) {
+    // Found config file
+    root = new OrigamiFileMap(currentTree.path);
+  } else {
+    // Try looking for package.json
+    value = await currentTree.get(packageFileName);
+    if (value) {
+      // Found package.json
+      root = new OrigamiFileMap(currentTree.path);
+    } else {
+      // Move up a folder and try again
+      const parentPath = path.dirname(dirname);
+      if (parentPath !== dirname) {
+        root = await projectRootFromPath(parentPath);
+      } else {
+        // At filesystem root, use current working directory
+        root = new OrigamiFileMap(process.cwd());
+      }
+    }
+  }
+
+  mapPathToRoot.set(dirname, root);
+  return root;
+}

package/src/protocols/fetchAndHandleExtension.js

@@ -13,6 +13,11 @@ export default async function fetchAndHandleExtension(href) {
   }
   let buffer = await response.arrayBuffer();
 
+  const mediaType = response.headers.get("Content-Type");
+  if (mediaType) {
+    /** @type {any} */ (buffer).mediaType = mediaType;
+  }
+
   // Attach any loader defined for the file type.
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();

package/src/protocols/package.js

@@ -2,66 +2,53 @@ import { Tree, keysFromPath } from "@weborigami/async-tree";
 import projectRoot from "../project/projectRoot.js";
 
 /**
- * @param {string[]} keys
+ * The package: protocol handler
+ *
+ * @param {any[]} args
  */
-export default async function packageNamespace(...keys) {
-  const parent = await projectRoot();
-
-  let name = keys.shift();
-  let organization;
-  if (name?.startsWith("@")) {
-    // First key is an npm organization
-    organization = name;
-    if (keys.length === 0) {
-      // Return a function that will process the next key
-      return async (name, ...keys) =>
-        getPackage(parent, organization, name, keys);
-    }
-    name = keys.shift();
-  }
-
-  return getPackage(parent, organization, name, keys);
-}
-
-async function getPackage(parent, organization, name, keys) {
-  const packagePath = ["node_modules"];
-  if (organization) {
-    packagePath.push(organization);
+export default async function packageProtocol(...args) {
+  const state = args.pop(); // Remaining args are the path
+  const root = await projectRoot(state);
+
+  // Identify the path to the package root
+  const packageRootPath = ["node_modules"];
+  const name = args.shift();
+  packageRootPath.push(name);
+  if (name.startsWith("@")) {
+    // First key is an npm organization, add next key as name
+    packageRootPath.push(args.shift());
   }
-  packagePath.push(name);
-
-  const parentScope = await Tree.scope(parent);
-  const packageRoot = await Tree.traverse(
-    // @ts-ignore
-    parentScope,
-    ...packagePath
-  );
 
+  // Get the package root (top level folder of the package)
+  const packageRoot = await Tree.traverse(root, ...packageRootPath);
   if (!packageRoot) {
-    throw new Error(`Can't find ${packagePath.join("/")}`);
+    throw new Error(`Can't find ${packageRootPath.join("/")}`);
   }
 
+  // Identify the main entry point
   const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
   if (!mainPath) {
     throw new Error(
-      `node_modules/${keys.join(
+      `${packageRootPath.join(
         "/"
       )} doesn't contain a package.json with a "main" entry.`
     );
   }
 
+  // Identify the folder containing the main entry point
   const mainKeys = keysFromPath(mainPath);
-  const mainContainerKeys = mainKeys.slice(0, -1);
-  const mainFileName = mainKeys[mainKeys.length - 1];
-  const mainContainer = await Tree.traverse(packageRoot, ...mainContainerKeys);
+  const mainFileName = mainKeys.pop();
+  const mainContainer = await Tree.traverse(packageRoot, ...mainKeys);
   const packageExports = await mainContainer.import(mainFileName);
 
   let result =
     "default" in packageExports ? packageExports.default : packageExports;
 
-  if (keys.length > 0) {
-    result = await Tree.traverse(result, ...keys);
+  // If there are remaining args, traverse into the package exports
+  if (args.length > 0) {
+    result = await Tree.traverse(result, ...args);
   }
 
   return result;
 }
+packageProtocol.needsState = true;