* Separate processing @id and @type in expansion, due to differing rules.

Author: gkellogg

lib/compact.js

@@ -219,31 +219,47 @@ api.compact = async ({
     for(const expandedProperty of keys) {
       const expandedValue = element[expandedProperty];
 
-      // compact @id and @type(s)
-      if(expandedProperty === '@id' || expandedProperty === '@type') {
-        // if using a type-scoped context, resolve type values against previous
-        // context
-        const isType = expandedProperty === '@type';
-        const valueContext = isType ?
-          (activeCtx.previousContext || activeCtx) : activeCtx;
+      // compact @id
+      if(expandedProperty === '@id') {
         let compactedValue = _asArray(expandedValue).map(
           expandedIri => api.compactIri({
-            activeCtx: valueContext,
+            activeCtx,
+            iri: expandedIri,
+            relativeTo: {vocab: false}
+          }));
+        if(compactedValue.length === 1) {
+          compactedValue = compactedValue[0];
+        }
+
+        // use keyword alias and add value
+        const alias = api.compactIri(
+          {activeCtx, iri: '@id', relativeTo: {vocab: true}});
+
+          rval[alias] = compactedValue;
+        continue;
+      }
+
+      // compact @type(s)
+      if(expandedProperty === '@type') {
+        // resolve type values against previous context
+        let compactedValue = _asArray(expandedValue).map(
+          expandedIri => api.compactIri({
+            activeCtx: inputCtx,
             iri: expandedIri,
-            relativeTo: {vocab: isType}
+            relativeTo: {vocab: true}
           }));
         if(compactedValue.length === 1) {
           compactedValue = compactedValue[0];
         }
 
         // use keyword alias and add value
         const alias = api.compactIri(
-          {activeCtx, iri: expandedProperty, relativeTo: {vocab: true}});
+          {activeCtx, iri: '@type', relativeTo: {vocab: true}});
         const container = _getContextValue(
           activeCtx, alias, '@container') || [];
 
         // treat as array for @type if @container includes @set
-        const typeAsSet = isType &&
+        const typeAsSet = 
           container.includes('@set') &&
           _processingMode(activeCtx, 1.1);
         const isArray =

lib/expand.js

@@ -209,6 +209,9 @@ api.expand = async ({
       {activeCtx, localCtx: element['@context'], options});
   }
 
+  // set the type-scoped context to the context on input, for use later
+  typeScopedContext = activeCtx;
+
   // look for scoped contexts on `@type`
   for(const key of keys) {
     const expandedProperty = _expandIri(activeCtx, key, {vocab: true}, options);
@@ -220,14 +223,13 @@ api.expand = async ({
         Array.isArray(value) ?
           (value.length > 1 ? value.slice().sort() : value) : [value];
       for(const type of types) {
-        const ctx = _getContextValue(
-          activeCtx.previousContext || activeCtx, type, '@context');
+        const ctx = _getContextValue(typeScopedContext, type, '@context');
         if(!_isUndefined(ctx)) {
           activeCtx = await _processContext({
             activeCtx,
             localCtx: ctx,
             options,
-            isTypeScopedContext: true
+            propagate: false
           });
         }
       }
@@ -494,7 +496,7 @@ async function _expandObject({
         expandedParent, '@type',
         _asArray(value).map(v =>
           _isString(v) ?
-            _expandIri(activeCtx.previousContext || activeCtx, v,
+            _expandIri(typeScopedContext, v,
               {base: true, vocab: true}, options) : v),
         {propertyIsArray: options.isFrame});
       continue;