import React, { forwardRef, useMemo } from 'react';
import { StyleSheet, Text } from 'react-native';
import { TemplateCallback, TemplateCallbackWorklet } from './EventHandler';
import { ForEachBase } from './Components/ForEachBase';
import InflatorRepository, {
ComponentPool,
TemplateItem,
} from './InflatorRepository';
import { CaseBase } from './Components/Switch';
import { useTemplateContext } from './TemplateContext';
import {
createTemplateValue,
isTemplateValue,
TemplateValue,
TemplateValueInternal,
} from './TemplateValue';
import { generateId } from './Utils';
import { useWishlistContext } from './WishlistContext';
// This is based on types from @types/react-native createAnimatedComponent.
type Nullable = undefined | null;
type Primitive = string | number | boolean | symbol;
type Builtin = Function | Date | Error | RegExp;
interface WithTemplateArray
extends Array> {}
type WithTemplateObject = {
[K in keyof T]: WithTemplateValue;
};
type WithTemplateValue = T extends Builtin | Nullable
? T
: T extends Primitive
? T | TemplateValue
: T extends Array
? WithTemplateArray
: T extends {}
? WithTemplateObject
: T;
type NonTemplateProps = 'key' | 'ref';
export type TemplateProps = {
[key in keyof T]: key extends NonTemplateProps
? T[key]
: WithTemplateValue;
};
export interface TemplateComponent>
extends React.FC>> {}
function setInObject(obj: any, path: string[], value: any) {
'worklet';
let current = obj;
for (let i = 0; i < path.length - 1; i++) {
current[path[i]] = current[path[i]] ?? {};
current = current[path[i]];
}
current[path[path.length - 1]] = value;
}
function traverseObject(
obj: any,
callback: (path: string[], value: any) => void,
) {
const stack: { path: string[]; value: any }[] = [{ path: [], value: obj }];
while (stack.length > 0) {
const { path, value } = stack.pop()!;
if (
value &&
typeof value === 'object' &&
!isTemplateValue(value) &&
!(value instanceof TemplateCallback) &&
(path.length === 0 || path[path.length - 1] !== 'children')
) {
Object.keys(value).forEach((key) => {
stack.push({ path: [...path, key], value: value[key] });
});
} else {
callback(path, value);
}
}
}
function convertToTemplateValue(value: unknown, path: string[]) {
let curTemplateType = value;
return {
// TODO(janic): Need to call remove for template values created here.
templateValue: createTemplateValue(() => {
'worklet';
return curTemplateType;
}),
targetPath: path,
};
}
export function createTemplateComponent>(
Component: T,
addProps?: (
templateItem: TemplateItem,
props: any,
inflatorId: string,
pool: ComponentPool,
rootValue: any,
) => void,
): TemplateComponent {
const WishListComponent = forwardRef(({ style, ...props }, ref) => {
const { inflatorId } = useWishlistContext();
const { templateType } = useTemplateContext();
const nativeId = useMemo(generateId, []);
const otherPropsMemoized = useMemo(() => {
const resolvedStyle = StyleSheet.flatten(style);
const templateValues: {
templateValue: TemplateValueInternal;
targetPath: string[];
}[] = [];
const templateCallbacks: {
worklet: TemplateCallbackWorklet;
eventName: string;
}[] = [];
const otherProps = {};
traverseObject({ ...props, style: resolvedStyle }, (path, value) => {
const applyHacks = () => {
// Text component needs to receive a string child to work properly.
// @ts-expect-error TODO: fix this.
if (path[0] === 'children' && Component === Text) {
setInObject(otherProps, path, ' ');
}
};
if (isTemplateValue(value)) {
templateValues.push({ templateValue: value, targetPath: path });
applyHacks();
} else if (value instanceof TemplateCallback) {
templateCallbacks.push({
worklet: value.worklet,
// Callbacks should never be in objects.
eventName: value.eventName ?? path[0].replace(/^on/, 'top'),
});
// Events have a boolean prop associated to know whether the
// function is set or not, so we still want to pass the prop.
setInObject(otherProps, path, () => {});
} else {
// @ts-expect-error TODO: fix this.
if (Component === ForEachBase && path[0] === 'template') {
templateValues.push(convertToTemplateValue(value, path));
}
if (
// @ts-expect-error TODO: fix this.
Component === CaseBase &&
path[0] === 'value' &&
!isTemplateValue(value)
) {
templateValues.push(convertToTemplateValue(value, path));
}
if (
// @ts-expect-error TODO: fix this.
Component === Text &&
path[0] === 'children' &&
!isTemplateValue(value)
) {
templateValues.push(convertToTemplateValue(value, path));
}
setInObject(otherProps, path, value);
}
});
InflatorRepository.registerMapping(
inflatorId,
nativeId,
templateType,
(value, templateItem, pool, rootValue) => {
'worklet';
templateValues.forEach(({ templateValue }) => {
templateValue.__setDirty();
});
const propsToSet: any = {};
templateValues.forEach(({ templateValue, targetPath }) => {
setInObject(propsToSet, targetPath, templateValue.value());
});
templateCallbacks.forEach(({ eventName, worklet }) => {
templateItem.setCallback(eventName, (ev) => {
worklet(ev, value, rootValue);
});
});
// Styles need to be passed as props.
const { style: styleForProps, ...otherPropsToSet } = propsToSet;
const finalPropsToSet = { ...otherPropsToSet, ...styleForProps };
if (addProps) {
addProps(
templateItem,
finalPropsToSet,
inflatorId,
pool,
rootValue,
);
} else {
templateItem.addProps(finalPropsToSet);
}
},
);
return otherProps;
// TODO: This will change on every render, if we want this memo to work properly we need
// to shallow compare the props object.
}, [inflatorId, nativeId, props, style, templateType]);
// @ts-expect-error: this is ok.
return ;
}) as unknown as TemplateComponent;
WishListComponent.displayName = `WishList(${Component.displayName})`;
return WishListComponent;
}