@developer_tribe/react-builder 1.0.4 → 1.0.5

package/src/utils/patterns.ts

@@ -1,4 +1,4 @@
-import { patterns as generatedPatterns } from '../build-components';
+import { patterns as generatedPatterns } from '../build-components/patterns.generated';
 import type { NodeDefaultAttribute } from '../types/Node';
 
 export type AttributeMeta = {
@@ -8,6 +8,15 @@ export type AttributeMeta = {
   specialCategory?: 'padding' | 'margin' | 'offset' | null | string;
   sort?: number;
   preferedScale?: 's' | 'vs' | 'f' | '%' | '' | string;
+  /**
+   * When true, this attribute should remain visible even if the component
+   * metadata requests hiding all attributes (e.g. `meta.hideAllAttributes`).
+   */
+  forceVisible?: boolean;
+  /**
+   * Alias for `forceVisible` used by some patterns.
+   */
+  override?: boolean;
 };
 
 export type SpecialCategoryMeta = {
@@ -24,6 +33,9 @@ type PatternMeta = {
   specialCategories?: Record<string, SpecialCategoryMeta>;
   desiredParent?: string[];
   desiredChildren?: string[];
+  mockableFeatures?: Record<string, boolean>;
+  /** If true, hide all attributes in the editor except ones with `forceVisible/override`. */
+  hideAllAttributes?: boolean;
 };
 
 type Pattern = {
@@ -52,9 +64,51 @@ const patternIndex: Map<string, Pattern> = new Map(
   patterns.map((p) => [p.pattern.type, p]),
 );
 
+function pascalToCamelCase(s: string): string {
+  if (!s) return s;
+  return s[0].toLowerCase() + s.slice(1);
+}
+
+function pascalToKebabCase(s: string): string {
+  if (!s) return s;
+  // BackgroundImage -> background-image, IAPBackground -> iap-background
+  return s
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, '$1-$2')
+    .toLowerCase();
+}
+
+const typeAliases: Map<string, string> = new Map();
+for (const p of patterns) {
+  const canonical = p?.pattern?.type;
+  if (typeof canonical !== 'string' || !canonical) continue;
+  const aliases = [
+    canonical,
+    canonical.toLowerCase(),
+    pascalToCamelCase(canonical),
+    pascalToKebabCase(canonical),
+  ];
+  for (const a of aliases) {
+    if (!a) continue;
+    if (!typeAliases.has(a)) {
+      typeAliases.set(a, canonical);
+    }
+  }
+}
+
+/** Normalize legacy/variant component type strings to the canonical pattern.type (PascalCase). */
+export function normalizeComponentType(
+  type?: string | null,
+): string | undefined {
+  if (typeof type !== 'string' || !type) return undefined;
+  if (patternIndex.has(type)) return type;
+  return typeAliases.get(type) ?? typeAliases.get(type.toLowerCase());
+}
+
 export function getPatternByType(type?: string | null): Pattern | undefined {
   if (typeof type !== 'string') return undefined;
-  return patternIndex.get(type);
+  const normalized = normalizeComponentType(type) ?? type;
+  return patternIndex.get(normalized);
 }
 
 export function getAttributeSchema(
@@ -101,7 +155,12 @@ export function getTypeSchema(
 /** Utility: returns true if the type name refers to a primitive scalar */
 export function isPrimitiveType(typeName: string): boolean {
   return (
-    typeName === 'string' || typeName === 'number' || typeName === 'boolean'
+    typeName === 'string' ||
+    typeName === 'number' ||
+    typeName === 'boolean' ||
+    typeName === 'color' ||
+    typeName === 'size' ||
+    typeName === 'iconType'
   );
 }
 

package/src/utils/replaceLocalizationParams.ts

@@ -0,0 +1,15 @@
+export function replaceLocalizationParams(
+  text: string,
+  params?: Record<string, string> | null,
+): string {
+  if (!text) return text;
+  if (!params) return text;
+
+  return (
+    Object.entries(params).reduce((acc, [key, val]) => {
+      const needle = `@${key}`;
+      // Replace all occurrences without regex escaping pitfalls.
+      return acc.split(needle).join(String(val));
+    }, text) || text
+  );
+}