@maplibre/maplibre-react-native 10.0.0-alpha.27 → 10.0.0-alpha.28

package/scripts/templates/component.md.ejs

@@ -1,125 +0,0 @@
-<%
-  const component = locals.component;
-  const helpers = locals.helpers;
--%>
-<!-- <%= helpers.autoGeneratedHeader.doNotModify %> -->
-<!-- <%= helpers.autoGeneratedHeader.generatedFrom(component.filePath) %> -->
-# `<MapLibreGL.<%- component.name %> />`
-<%- helpers.replaceNewLine(component.description) %>
-
-<%_ if (component.props && component.props.length) { _%>
-## Props
-| Prop | Type | Default | Required | Description |
-| ---- | :--: | :-----: | :------: | :----------: |
-<%- helpers.propMarkdownTableRows(component) %>
-<%_ } _%>
-
-<%_ if (component.methods && component.methods.length) { _%>
-## Methods
-<%_ for (let method of component.methods) { _%>
-### <%- helpers.getMarkdownMethodSignature(method) %>
-
-<%- helpers.replaceNewLine(method.description) %>
-
-<%_ if (method.params && method.params.length) { _%>
-#### Arguments
-| Name | Type | Required | Description  |
-| ---- | :--: | :------: | :----------: |
-<%- helpers.methodMarkdownTableRow(method) %>
-<%_ } _%>
-
-<%- helpers.getMarkdownMethodExamples(method) %>
-<%_ } _%>
-<%_ } _%>
-
-<%_ if (component.styles && component.styles.length) { _%>
-## Styles
-
-<%_ for (let i = 0; i < component.styles.length; i++) { _%>
-<%
-const style = component.styles[i];
--%>
-* <a href="#name<%- i > 0 ? '-' + i : '' -%>">`<%- style.name %>`</a><br/>
-<%_ } _%>
-
-<%_ for (let style of component.styles) { _%>
-
-### `<%- style.name %>`
-
-<%- style.description %>
-
-<dl>
-    <dt>Type</dt>
-    <dd>
-        <code><%- style.type %></code>
-    </dd>
-    <%_ if (helpers.exists(style.default)) { _%>
-        <dt>Default Value</dt>
-        <dd><code><%= helpers.getStyleDefaultValue(style) %></code></dd>
-    <%_ } _%>
-    <%_ if (style.type === 'enum') { _%>
-    <dt>Supported Values</dt>
-    <dd>
-        <ul>
-            <%_ for (var i = 0; i < style.values.length; i++) { _%>
-                <li>
-                    <code><%- style.values[i].value %></code>: <%- style.values[i].doc %>
-                </li>
-            <%_ } _%>
-            <%_ } _%>
-        </ul>
-    </dd>
-    <%_ if (helpers.exists(style.units)) { _%>
-        <dt>Units</dt>
-        <dd><code><%- style.units %></code></dd>
-    <%_ } _%>
-    <%_ if (helpers.exists(style.minimum)) { _%>
-        <dt>Minimum</dt>
-        <dd><code><%- style.minimum %></code></dd>
-    <%_ } _%>
-    <%_ if (helpers.exists(style.maximum)) { _%>
-        <dt>Maximum</dt>
-        <dd><code><%- style.maximum %></code></dd>
-    <%_ } _%>
-    <%_ if (style.requires.length) { _%>
-        <dt>Requires</dt>
-        <dd><code><%- style.requires.join(', ') %></code></dd>
-    <%_ } _%>
-    <%_ if (style.disabledBy.length) { _%>
-        <dt>Disabled By</dt>
-        <dd><code><%- style.disabledBy.join(', ') %></code></dd>
-    <%_ } _%>
-    <%_ if (style.allowedFunctionTypes.length) { _%>
-        <dt>Supported Style Functions</dt>
-        <dd><code><%- style.allowedFunctionTypes.join(', ') %></code></dd>
-    <%_ } _%>
-    <%_ if (style.expression) { _%>
-        <dt>Expression Parameters</dt>
-        <dd><code><%- (style.expression.parameters || []).join(', ') %></code></dd>
-    <%_ } _%>
-</dl>
-
-<%_ if (style.transition) { _%>
-### `<%- style.name %>Transition`
-
-The transition affecting any changes to this layer’s <%- style.name %> property.
-
-<dl>
-  <dt>Type</dt>
-  <dd>
-    <code>{ duration, delay }</code>
-  </dd>
-
-  <dt>Units</dt>
-  <dd>
-    <code>milliseconds</code>
-  </dd>
-
-  <dt>Default Value</dt>
-  <dd>
-    <code>{duration: 300, delay: 0}</code>
-  </dd>
-</dl>
-<%_ } %>
-<%_ } _%>
-<%_ } _%>

package/scripts/templates/styleMap.ts.ejs

@@ -1,86 +0,0 @@
-<%
-  const layers = locals.layers;
-  const helpers = locals.helpers;
--%>
-/* eslint-disable */
-// <%= helpers.autoGeneratedHeader.doNotModify %>
-// <%= helpers.autoGeneratedHeader.generatedFrom(locals.filePath) %>
-
-import { isAndroid } from './index';
-
-export const StyleTypes = {
-  Constant: 'constant',
-  Color: 'color',
-  Transition: 'transition',
-  Translation: 'translation',
-  Function: 'function',
-  Image: 'image',
-  Enum: 'enum',
-};
-
-export function getStyleType(styleProp: keyof typeof styleExtras): string {
-  if (!isAndroid() && styleExtras[styleProp]) {
-    return styleExtras[styleProp].iosType;
-  }
-
-  if (styleMap[styleProp]) {
-    return styleMap[styleProp];
-  }
-
-  throw new Error(`${styleProp} is not a valid MapLibre layer style`);
-}
-
-const styleMap = {
-  <%_ for (let layer of layers) { _%>
-  <%_ for (let prop of layer.properties) { _%>
-  <%_ if (prop.name !== 'visibility') { _%>
-  <%= prop.name %>: <%- helpers.jsStyleType(prop) %>,
-  <%_ if (prop.transition) { _%>
-  <%= prop.name %>Transition: StyleTypes.Transition,
-  <%_ } _%>
-  <%_ } _%>
-  <%_ } _%>
-
-  <%_ } _%>
-  visibility: StyleTypes.Constant,
-};
-
-export const styleExtras = {
-  // padding
-  iconTextFitPadding: {
-    iosType: 'edgeinsets',
-  },
-
-  // offsets
-  iconOffset: {
-    iosType: 'vector',
-  },
-  textOffset: {
-    iosType: 'vector',
-  },
-  lineOffset: {
-    iosType: 'vector',
-  },
-
-  // translates
-  fillTranslate: {
-    iosType: 'vector',
-  },
-  lineTranslate: {
-    iosType: 'vector',
-  },
-  iconTranslate: {
-    iosType: 'vector',
-  },
-  textTranslate: {
-    iosType: 'vector',
-  },
-  circleTranslate: {
-    iosType: 'vector',
-  },
-  fillExtrusionTranslate: {
-    iosType: 'vector',
-  },
-};
-
-export default styleMap;

package/scripts/utils/DocJSONBuilder.ts

@@ -1,463 +0,0 @@
-import { exec } from "child_process";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import * as docgen from "react-docgen";
-import { parseJsDoc } from "react-docgen/dist/utils";
-
-import { JSDocNodeTree } from "./JSDocNodeTree";
-import { pascalCase } from "./TemplateHelpers";
-
-const WORKSPACE_ROOT = path.join(__dirname, "..", "..");
-
-const COMPONENT_DIRECTORY = path.join(
-  WORKSPACE_ROOT,
-  "javascript",
-  "components",
-);
-const MODULES_DIRECTORY = path.join(WORKSPACE_ROOT, "javascript", "modules");
-const OUTPUT_PATH = path.join(WORKSPACE_ROOT, "docs", "docs.json");
-
-const IGNORE_METHODS = ["setNativeProps"];
-
-const fileExtensionsRegex = /.(js|tsx|(?<!d.)ts)$/;
-
-export class DocJSONBuilder {
-  _styledLayers: any;
-
-  constructor(styledLayers: any) {
-    this._styledLayers = {};
-
-    for (const styleLayer of styledLayers) {
-      const ComponentName = pascalCase(styleLayer.name);
-      const fakeLayers = ["Light", "Atmosphere", "Terrain"];
-      if (fakeLayers.includes(ComponentName)) {
-        this._styledLayers[ComponentName] = styleLayer;
-      } else {
-        this._styledLayers[ComponentName + "Layer"] = styleLayer;
-      }
-    }
-  }
-
-  get options() {
-    return {
-      match: fileExtensionsRegex,
-      shortName: true,
-      sort: true,
-    };
-  }
-
-  isPrivateMethod(methodName = "") {
-    return !methodName || methodName.charAt(0) === "_";
-  }
-
-  postprocess(component: any, name: string) {
-    // Remove all private methods and parse examples from docblock
-
-    if (!Array.isArray(component.methods)) {
-      return;
-    }
-
-    component.name = name;
-
-    // Main description
-    component.description = component.description?.replace(
-      /(\n*)(@\w+) (\{.*})/g,
-      "",
-    );
-
-    // Styles
-    if (this._styledLayers[name] && this._styledLayers[name].properties) {
-      component.styles = [];
-
-      for (const prop of this._styledLayers[name].properties) {
-        const docStyle = {
-          name: prop.name,
-          type: prop.type,
-          values: [] as any[],
-          minimum: prop.doc.minimum,
-          maximum: prop.doc.maximum,
-          units: prop.doc.units,
-          default: prop.doc.default,
-          description: prop.doc.description,
-          requires: prop.doc.requires,
-          disabledBy: prop.doc.disabledBy,
-          allowedFunctionTypes: prop.allowedFunctionTypes || [],
-          expression: prop.expression,
-          transition: prop.transition,
-        };
-        if (prop.type === "enum") {
-          docStyle.values = Object.keys(prop.doc.values).map((value) => {
-            return { value, doc: prop.doc.values[value].doc };
-          });
-        } else if (prop.type === "array") {
-          docStyle.type = `${docStyle.type}<${prop.value}>`;
-        }
-
-        component.styles.push(docStyle);
-      }
-    }
-
-    function mapNestedProp(propMeta: any) {
-      const result = {
-        type: {
-          name: propMeta.name,
-          value: propMeta.value,
-        },
-        description: propMeta.description,
-        required: propMeta.required,
-      };
-
-      if (propMeta.value) {
-        result.type.value = propMeta.value;
-      }
-
-      return result;
-    }
-
-    function tsTypeDesc(tsType: TSType) {
-      if (!tsType?.name) {
-        return null;
-      }
-
-      if (tsType.name === "signature") {
-        if (tsType.raw.length < 200) {
-          return `${tsType.raw
-            .replace(/(\n|\s)/g, "")
-            .replace(/(\|)/g, "\\|")}`;
-        } else {
-          return "FIX ME FORMAT BIG OBJECT";
-        }
-      } else if (tsType.name === "union") {
-        if (tsType.raw) {
-          // Props
-          return tsType.raw.replace(/\|/g, "\\|");
-        } else if (tsType.elements) {
-          // Methods
-          return tsType.elements.map((element) => element.name).join(" \\| ");
-        }
-      }
-
-      return tsType.name;
-    }
-
-    type TSTypeType = {
-      name: string;
-      raw: string;
-    };
-
-    type TSFuncSignature = {
-      arguments: { type: TSType; name: string }[];
-      return: TSType;
-    };
-
-    type TSKVProperties = { key: string; value: TSType; description: string }[];
-
-    type TSObjectSignature = {
-      properties: TSKVProperties;
-    };
-
-    interface TSVoidType extends TSTypeType {
-      name: "void";
-      type: never;
-    }
-
-    interface TSUnionType extends TSTypeType {
-      name: "union";
-      type: never;
-      elements: any[];
-    }
-
-    interface TSFunctionType extends TSTypeType {
-      name: "signature";
-      type: "function";
-      signature: TSFuncSignature;
-    }
-
-    interface TSObjectType extends TSTypeType {
-      name: "signature";
-      type: "object";
-      signature: TSObjectSignature;
-    }
-
-    type TSType = TSVoidType | TSUnionType | TSFunctionType | TSObjectType;
-
-    function tsTypeIsFunction(tsType: TSType): tsType is TSFunctionType {
-      return "type" in tsType && tsType.type === "function";
-    }
-
-    function tsTypeIsObject(tsType: TSType): tsType is TSObjectType {
-      return "type" in tsType && tsType.type === "object";
-    }
-
-    function tsTypeDump(tsType: TSType): string {
-      if (tsTypeIsFunction(tsType)) {
-        const { signature } = tsType;
-        return `(${signature.arguments
-          .map(({ name, type }) => `${name}:${tsTypeDump(type)}`)
-          .join(", ")}) => ${tsTypeDump(signature.return)}`;
-      } else if (tsTypeIsObject(tsType)) {
-        const { signature } = tsType;
-        return `{${signature.properties
-          .map(({ key, value }) => `${key}: ${tsTypeDump(value)}`)
-          .join(", ")}}`;
-      } else {
-        return tsType.name;
-      }
-    }
-
-    function tsTypeDescType(tsType?: TSType) {
-      if (!tsType) {
-        return null;
-      }
-
-      if (tsType.name === "signature" && tsType.type === "object") {
-        const { properties } = tsType.signature;
-        if (properties) {
-          const value = properties.map((kv) => {
-            return mapProp(
-              mapNestedProp({ ...kv.value, description: kv.description }),
-              kv.key,
-              false,
-            );
-          });
-          return { name: "shape", value };
-        } else if (tsType.raw.length < 200) {
-          return `${tsType.raw
-            .replace(/(\n|\s)/g, "")
-            .replace(/(\|)/g, "\\|")}`;
-        } else {
-          return "FIX ME FORMAT BIG OBJECT";
-        }
-      } else if (tsType.name === "signature" && tsType.type === "function") {
-        return { name: "func", funcSignature: tsTypeDump(tsType) };
-      } else if (tsType.name === "union") {
-        if (tsType.raw) {
-          // Props
-          return tsType.raw.replace(/\|/g, "\\|");
-        } else if (tsType.elements) {
-          // Methods
-          return tsType.elements.map((e) => e.name).join(" \\| ");
-        }
-      }
-
-      return tsType.name;
-    }
-
-    function mapProp(
-      propMeta: any,
-      propName: string | undefined,
-      array: boolean,
-    ) {
-      let result: Record<string, any> = {};
-      if (!array) {
-        result = {
-          name: propName || "FIX ME NO NAME",
-          required: propMeta.required || false,
-          type:
-            propMeta.type?.name ||
-            tsTypeDescType(propMeta.tsType) ||
-            "FIX ME UNKNOWN TYPE",
-          default: !propMeta.defaultValue
-            ? "none"
-            : propMeta.defaultValue.value.replace(/\n/g, ""),
-          description: propMeta.description || "FIX ME NO DESCRIPTION",
-        };
-        if (
-          result.type &&
-          result.type.name === "func" &&
-          result.type.funcSignature
-        ) {
-          result.description = `${result.description}\n*signature:*\`${result.type.funcSignature}\``;
-        }
-      } else {
-        if (propName) {
-          result.name = propName;
-        }
-        if (propMeta.required !== undefined) {
-          result.required = propMeta.required;
-        }
-        result.type =
-          (propMeta.type && propMeta.type.name) ||
-          tsTypeDescType(propMeta.tsType) ||
-          "FIX ME UNKNOWN TYPE";
-        if (propMeta.defaultValue) {
-          result.default = propMeta.defaultValue.value.replace(/\n/g, "");
-        }
-        if (propMeta.description) {
-          result.description = propMeta.description;
-        }
-      }
-
-      if (
-        propMeta.type &&
-        propMeta.type.name === "arrayOf" &&
-        propMeta.type.value
-      ) {
-        result.type = {
-          name: "array",
-          value: mapProp(mapNestedProp(propMeta.type.value), undefined, true),
-        };
-      }
-
-      if (propMeta.type && propMeta.type.name === "func") {
-        const jsdoc = parseJsDoc(propMeta.description);
-        if (jsdoc && jsdoc.description) {
-          result.description = jsdoc.description;
-        }
-        if (jsdoc && jsdoc.params && jsdoc.params.length > 0) {
-          result.params = jsdoc.params;
-        }
-        if (jsdoc && jsdoc.returns) {
-          result.returns = jsdoc.returns;
-        }
-      }
-      if (
-        propMeta.type &&
-        propMeta.type.name === "shape" &&
-        propMeta.type.value
-      ) {
-        const type = propMeta.type.value;
-        const value = Object.keys(type).map((_name) =>
-          mapProp(mapNestedProp(type[_name]), _name, false),
-        );
-        result.type = { name: "shape", value };
-      }
-      return result;
-    }
-
-    // props
-    component.props = Object.keys(component.props).map((propName) => {
-      const propMeta = component.props[propName];
-
-      return mapProp(propMeta, propName, false);
-    });
-
-    // methods
-    const privateMethods: string[] = [];
-    for (const method of component.methods) {
-      if (this.isPrivateMethod(method.name)) {
-        privateMethods.push(method.name);
-        continue;
-      }
-
-      if (method.docblock) {
-        const examples = method.docblock
-          .split("@")
-          .filter((block: string) => block.startsWith("example"));
-        method.examples = examples.map((example: any) =>
-          example.substring("example".length),
-        );
-      }
-    }
-    privateMethods.push(...IGNORE_METHODS);
-
-    component.methods = component.methods.filter(
-      (method: any) => !privateMethods.includes(method.name),
-    );
-
-    component.methods.forEach((method: any) => {
-      method.params.forEach((param: any) => {
-        param.type = { name: tsTypeDesc(param.type) };
-      });
-    });
-
-    console.log(
-      `Processed ${component.name} (${component.props?.length ?? 0} props, ${
-        component.methods?.length ?? 0
-      } methods)`,
-    );
-  }
-
-  async generateReactComponentsTask(results: Record<string, any>) {
-    const filesNames = await fs.readdir(COMPONENT_DIRECTORY);
-
-    const files = await Promise.all(
-      filesNames.map(async (base) => {
-        return {
-          base,
-          content: await fs.readFile(
-            path.join(COMPONENT_DIRECTORY, base),
-            "utf-8",
-          ),
-        };
-      }),
-    );
-
-    files.forEach(({ base, content }) => {
-      const parsedComponents = docgen.parse(content, {
-        babelOptions: {
-          filename: base,
-        },
-      });
-
-      const [parsed] = parsedComponents;
-
-      results[path.parse(base).name] = {
-        ...parsed,
-        filePath: path.relative(
-          WORKSPACE_ROOT,
-          path.join(COMPONENT_DIRECTORY, base),
-        ),
-      };
-
-      this.postprocess(results[path.parse(base).name], path.parse(base).name);
-    });
-  }
-
-  async generateModulesTask(results: Record<string, any>) {
-    return new Promise<void>((resolve, reject) => {
-      exec(
-        `yarn run documentation build ${MODULES_DIRECTORY} -f json`,
-        (err, stdout, stderr) => {
-          if (err || stderr) {
-            reject(err || stderr);
-            return;
-          }
-
-          const modules = JSON.parse(stdout);
-          for (const module of modules) {
-            const node = new JSDocNodeTree(module);
-            const name = `${module.name
-              .charAt(0)
-              .toLowerCase()}${module.name.substring(1)}`;
-
-            results[name] = {
-              name,
-              filePath: path.relative(WORKSPACE_ROOT, module.context.file),
-              description: node.getText(),
-              props: [],
-              styles: [],
-              methods: node.getMethods(),
-            };
-          }
-
-          resolve();
-        },
-      );
-    });
-  }
-
-  sortObject(unsorted: Record<string, any>) {
-    return Object.keys(unsorted)
-      .sort()
-      .reduce(
-        (acc, key) => ({
-          ...acc,
-          [key]: unsorted[key],
-        }),
-        {},
-      );
-  }
-
-  async generate() {
-    const results = {};
-
-    await this.generateReactComponentsTask(results);
-    await this.generateModulesTask(results);
-
-    await fs.writeFile(
-      OUTPUT_PATH,
-      JSON.stringify(this.sortObject(results), null, 2),
-    );
-  }
-}