@lvce-editor/extension-detail-view 4.6.0 → 4.8.0

package/dist/extensionDetailViewWorkerMain.js

@@ -30,6 +30,7 @@ const Id = 'ID';
 const Identifier = 'Identifier';
 const ImportTime = 'Import Time: ';
 const Installation = 'Installation';
+const InvalidLink = 'Invalid link';
 const Issues = 'Issues';
 const JsonValidation$1 = 'Json Validation';
 const Label = 'Label';
@@ -42,18 +43,21 @@ const NoReadmeFound = 'No Readme Found.';
 const OpenImageInNewTab = 'Open Image in New Tab';
 const OpenInNewTab = 'Open in New Tab';
 const ProgrammingLanguages$1 = 'Programming Languages';
+const PropertyMustBeOfTypeString = 'Property must be a string';
 const Published = 'Published';
 const Repository = 'Repository';
 const Resources$1 = 'Resources';
 const RuntimeStatus$1 = 'Runtime Status';
 const SaveImageAs = 'Save Image as';
 const Schema = 'Schema';
+const SchemaNotFound = 'Schema not found';
 const ScrollToTop$1 = 'Scroll to top';
 const SelectedFeatureUnknownOrUnsupported = 'Selected feature is unknown or unsupported';
 const Selector = 'Selector';
 const SetColorTheme$1 = 'Set Color Theme';
 const Settings$1 = 'Settings';
 const Size = 'Size';
+const StringMustNotBeEmpty = 'String must not be empty';
 const Theme$1 = 'Theme';
 const Uninstall$1 = 'Uninstall';
 const UnsupportedFeature = 'Unsupported Feature';
@@ -207,11 +211,50 @@ const repository = () => {
 const license = () => {
   return i18nString(License);
 };
+const propertyMustBeOfTypeString = () => {
+  return i18nString(PropertyMustBeOfTypeString);
+};
+const stringMustNotBeEmpty = () => {
+  return i18nString(StringMustNotBeEmpty);
+};
+const schemaNotFound = () => {
+  return i18nString(SchemaNotFound);
+};
+const invalidLink = () => {
+  return i18nString(InvalidLink);
+};
+
+const getActivationEntry = value => {
+  if (typeof value !== 'string') {
+    return {
+      isValid: false,
+      stringValue: JSON.stringify(value),
+      errorMessage: propertyMustBeOfTypeString()
+    };
+  }
+  if (!value) {
+    return {
+      isValid: false,
+      stringValue: '',
+      errorMessage: stringMustNotBeEmpty()
+    };
+  }
+  return {
+    isValid: true,
+    stringValue: value,
+    errorMessage: ''
+  };
+};
+const getActivationEntries = activation => {
+  return activation.map(getActivationEntry);
+};
 
 const getActivationEventsDetails = async extension => {
   const activationEvents = extension.activation || [];
+  const activationEntries = getActivationEntries(activationEvents);
   return {
-    activationEvents
+    activationEvents,
+    activationEntries
   };
 };
 
@@ -336,7 +379,20 @@ const code = {
   childCount: 1
 };
 const getActivationEventVirtualDom = event => {
-  return [li, code, text(event)];
+  const {
+    stringValue,
+    errorMessage,
+    isValid
+  } = event;
+  if (!isValid) {
+    return [{
+      type: Li,
+      childCount: 1,
+      title: errorMessage,
+      className: 'ListItem ListItemInvalid'
+    }, code, text(stringValue)];
+  }
+  return [li, code, text(stringValue)];
 };
 
 const getFeatureContentHeadingVirtualDom = heading => {
@@ -359,7 +415,7 @@ const getFeatureActivationEventsVirtualDom = activationEvents$1 => {
 };
 
 const getActivationEventsVirtualDom = state => {
-  return getFeatureActivationEventsVirtualDom(state.activationEvents);
+  return getFeatureActivationEventsVirtualDom(state.activationEntries);
 };
 
 const Text = 1;
@@ -441,16 +497,19 @@ const getCellCodeVirtualDom = (value, props) => {
   }, text(value)];
 };
 
-const getCellLinkVirtualDom = (value, {
-  href
-}) => {
+const getCellLinkVirtualDom = (value, props) => {
+  const tdClassName = props?.className ? `${TableCell} ${props.className}` : TableCell;
   return [{
     type: Td,
-    className: TableCell,
-    childCount: 1
+    className: tdClassName,
+    childCount: 1,
+    ...(props?.title ? {
+      title: props.title
+    } : {})
   }, {
     type: A,
-    href,
+    className: Link$1,
+    href: props?.href,
     childCount: 1
   }, text(value)];
 };
@@ -536,94 +595,187 @@ const getCommandsVirtualDom = state => {
   return getFeatureCommandsVirtualDom(state.commands);
 };
 
-const stringifyValue = value => {
-  return JSON.stringify(value);
+const isExternalLink = schema => {
+  return schema.startsWith('http://') || schema.startsWith('https://');
 };
-const getLinkOrTextEntry = (schema, schemaLinkUrl) => {
-  if (typeof schema !== 'string') {
-    return {
-      type: Text,
-      value: stringifyValue(schema)
-    };
-  }
-  if (schemaLinkUrl) {
-    return {
-      type: Link,
-      value: schema,
-      href: schemaLinkUrl
-    };
+const hasWhitespace = value => {
+  return /\s/.test(value);
+};
+const isOnlyDotsOrEmpty = value => {
+  const trimmed = value.trim();
+  return trimmed === '' || /^\.*$/.test(trimmed);
+};
+const isValidHttpUrl = value => {
+  try {
+    const url = new URL(value);
+    return (url.protocol === 'http:' || url.protocol === 'https:') && !!url.hostname;
+  } catch {
+    return false;
   }
-  return {
-    type: Text,
-    value: schema
-  };
 };
-
-const isExternalLink = schema => {
-  return schema.startsWith('http://') || schema.startsWith('https://');
+const isValidRelativePath = value => {
+  // Disallow schemes and whitespace
+  if (hasWhitespace(value)) {
+    return false;
+  }
+  if (value.includes('://')) {
+    return false;
+  }
+  if (isOnlyDotsOrEmpty(value)) {
+    return false;
+  }
+  // Allow paths like ./a.json, ../a.json, /a.json, schemas/a.json, a/b.json
+  if (!/^[./]?[A-Za-z0-9._\-/]+$/.test(value)) {
+    return false;
+  }
+  // Must contain at least one alphanumeric character
+  if (!/[A-Za-z0-9]/.test(value)) {
+    return false;
+  }
+  return true;
 };
 const getSchemaLinkUrl = (schema, extensionUri) => {
-  if (!schema) {
+  if (!schema || typeof schema !== 'string') {
     return '';
   }
-  if (typeof schema !== 'string') {
+  const trimmed = schema.trim();
+  if (trimmed !== schema) {
     return '';
   }
   if (isExternalLink(schema)) {
-    return schema;
+    return isValidHttpUrl(schema) ? schema : '';
+  }
+  if (!isValidRelativePath(schema)) {
+    return '';
+  }
+  try {
+    return new URL(schema, extensionUri).toString();
+  } catch {
+    return '';
   }
-  return new URL(schema, extensionUri).toString();
 };
 
-const stringify = value => {
+const existsJson = async schemaUrl => {
   try {
-    return JSON.stringify(value);
+    // TODO verify that response header is json
+    const response = await fetch(schemaUrl, {
+      method: 'HEAD'
+    });
+    return response.ok;
   } catch {
-    return String(value);
+    return false;
   }
 };
-const getJsonValidationTableEntry = (validation, extensionUri) => {
-  const invalidProps = {
-    className: TableCellInvalid,
-    title: 'property must be a string'
-  };
-  if (!validation || typeof validation !== 'object' || Array.isArray(validation)) {
-    const shown = stringify(validation);
+const getJsonValidationInfos = async (extensionUri, validations) => {
+  const validationInfos = [];
+  for (const validation of validations) {
+    const schema = validation.schema ?? validation.url;
+    const schemaLinkUrl = getSchemaLinkUrl(schema, extensionUri);
+    const {
+      fileMatch
+    } = validation;
+    if (typeof schema !== 'string') {
+      validationInfos.push({
+        isValid: false,
+        stringValue: JSON.stringify(schema),
+        schemaUrl: '',
+        errorMessage: propertyMustBeOfTypeString(),
+        fileMatch
+      });
+    } else if (schema && !schemaLinkUrl) {
+      validationInfos.push({
+        isValid: false,
+        stringValue: schema,
+        schemaUrl: schemaLinkUrl,
+        errorMessage: invalidLink(),
+        fileMatch
+      });
+    } else if (schemaLinkUrl) {
+      if (await existsJson(schemaLinkUrl)) {
+        validationInfos.push({
+          isValid: true,
+          stringValue: schema,
+          schemaUrl: schemaLinkUrl,
+          errorMessage: '',
+          fileMatch
+        });
+      } else {
+        validationInfos.push({
+          isValid: false,
+          stringValue: schema,
+          schemaUrl: schemaLinkUrl,
+          errorMessage: schemaNotFound(),
+          fileMatch
+        });
+      }
+    } else {
+      validationInfos.push({
+        isValid: true,
+        stringValue: schema,
+        schemaUrl: schemaLinkUrl,
+        errorMessage: '',
+        fileMatch
+      });
+    }
+  }
+  return validationInfos;
+};
+
+const getJsonValidationTableEntry = validationInfo => {
+  const {
+    isValid,
+    errorMessage,
+    schemaUrl,
+    stringValue,
+    fileMatch
+  } = validationInfo;
+  if (!isValid && schemaUrl) {
+    return [{
+      type: Code,
+      value: fileMatch
+    }, {
+      type: Link,
+      value: stringValue,
+      href: schemaUrl,
+      className: TableCellInvalid,
+      title: errorMessage
+    }];
+  }
+  if (!isValid) {
     return [{
       type: Text,
-      value: shown,
-      ...invalidProps
+      value: fileMatch
     }, {
       type: Text,
-      value: shown,
-      ...invalidProps
+      value: stringValue,
+      className: TableCellInvalid,
+      title: errorMessage
     }];
   }
-  const {
-    fileMatch
-  } = validation;
-  const schema = validation.schema ?? validation.url;
-  const schemaLinkUrl = getSchemaLinkUrl(schema, extensionUri);
-  const leftCell = typeof fileMatch === 'string' || Array.isArray(fileMatch) ? {
+  if (schemaUrl) {
+    return [{
+      type: Code,
+      value: fileMatch
+    }, {
+      type: Link,
+      value: stringValue,
+      href: schemaUrl
+    }];
+  }
+  return [{
     type: Code,
     value: fileMatch
-  } : {
-    type: Text,
-    value: stringify(fileMatch),
-    ...invalidProps
-  };
-  const rightEntry = typeof schema === 'string' ? getLinkOrTextEntry(schema, schemaLinkUrl) : {
+  }, {
     type: Text,
-    value: stringify(schema),
-    ...invalidProps
-  };
-  return [leftCell, rightEntry];
+    value: stringValue
+  }];
 };
 
 const getJsonValidationDetails = async extension => {
   const validations = extension.jsonValidation || [];
   const extensionUri = extension.uri || '';
-  const rows = validations.map(validation => getJsonValidationTableEntry(validation, extensionUri));
+  const validationInfos = await getJsonValidationInfos(extensionUri, validations);
+  const rows = validationInfos.map(getJsonValidationTableEntry);
   return {
     jsonValidation: rows
   };
@@ -835,7 +987,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String$1 = 4;
+const String = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
@@ -847,7 +999,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String$1;
+      return String;
     case 'object':
       if (value === null) {
         return Null;
@@ -864,7 +1016,7 @@ const getType = value => {
 };
 const string = value => {
   const type = getType(value);
-  if (type !== String$1) {
+  if (type !== String) {
     throw new AssertionError('expected value to be of type string');
   }
 };
@@ -3112,7 +3264,8 @@ const create = (uid, uri, x, y, width, height, platform, assetDir) => {
     paddingRight: 0,
     showSideBar: true,
     sideBarWidth: 0,
-    locationProtocol: ''
+    locationProtocol: '',
+    activationEntries: []
   };
   set(uid, state, state);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-detail-view",
-  "version": "4.6.0",
+  "version": "4.8.0",
   "description": "Extension Detail View Worker",
   "repository": {
     "type": "git",